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;
57 uint16_t nb_queue_pairs;
59 struct rte_cryptodev_config conf;
60 struct rte_cryptodev_qp_conf qp_conf;
73 const uint8_t *aad_data;
75 const uint8_t *p_data;
78 const uint8_t *c_data;
81 const uint8_t *t_data;
86 struct symmetric_session_attrs {
87 enum rte_crypto_cipher_operation cipher;
88 enum rte_crypto_auth_operation auth;
90 enum rte_crypto_cipher_algorithm cipher_algorithm;
91 const uint8_t *key_cipher_data;
92 uint32_t key_cipher_len;
94 enum rte_crypto_auth_algorithm auth_algorithm;
95 const uint8_t *key_auth_data;
96 uint32_t key_auth_len;
98 const uint8_t *iv_data;
104 #define ALIGN_POW2_ROUNDUP(num, align) \
105 (((num) + (align) - 1) & ~((align) - 1))
108 * This struct is needed to avoid unnecessary allocation or checking
109 * of allocation of crypto params with current alloc on the fly
113 struct crypto_params {
118 struct perf_test_params {
120 unsigned total_operations;
124 enum chain_mode chain;
126 enum rte_crypto_cipher_algorithm cipher_algo;
127 unsigned cipher_key_length;
128 enum rte_crypto_auth_algorithm auth_algo;
130 struct symmetric_session_attrs *session_attrs;
132 struct symmetric_op *symmetric_op;
135 #define MAX_NUM_OF_OPS_PER_UT (128)
137 struct crypto_unittest_params {
138 struct rte_crypto_sym_xform cipher_xform;
139 struct rte_crypto_sym_xform auth_xform;
141 struct rte_cryptodev_sym_session *sess;
143 struct rte_crypto_op *op;
145 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
146 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
151 static struct rte_cryptodev_sym_session *
152 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
153 enum rte_crypto_cipher_algorithm cipher_algo,
154 unsigned int cipher_key_len,
155 enum rte_crypto_auth_algorithm auth_algo);
156 static struct rte_cryptodev_sym_session *
157 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
158 enum rte_crypto_cipher_algorithm cipher_algo,
159 unsigned int cipher_key_len,
160 enum rte_crypto_auth_algorithm auth_algo);
161 static struct rte_cryptodev_sym_session *
162 test_perf_create_armv8_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 static struct rte_mbuf *
168 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
169 static inline struct rte_crypto_op *
170 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
171 struct rte_cryptodev_sym_session *sess, unsigned int data_len);
172 static inline struct rte_crypto_op *
173 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
174 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
175 enum chain_mode chain);
176 static inline struct rte_crypto_op *
177 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
178 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
179 enum chain_mode chain __rte_unused);
180 static inline struct rte_crypto_op *
181 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
182 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
183 enum chain_mode chain __rte_unused);
184 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
187 static const char *chain_mode_name(enum chain_mode mode)
190 case CIPHER_HASH: return "cipher_hash"; break;
191 case HASH_CIPHER: return "hash_cipher"; break;
192 case CIPHER_ONLY: return "cipher_only"; break;
193 case HASH_ONLY: return "hash_only"; break;
194 default: return ""; break;
198 static const char *pmd_name(enum rte_cryptodev_type pmd)
201 case RTE_CRYPTODEV_NULL_PMD: return RTE_STR(CRYPTODEV_NAME_NULL_PMD); break;
202 case RTE_CRYPTODEV_AESNI_GCM_PMD:
203 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
204 case RTE_CRYPTODEV_AESNI_MB_PMD:
205 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
206 case RTE_CRYPTODEV_QAT_SYM_PMD:
207 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
208 case RTE_CRYPTODEV_SNOW3G_PMD:
209 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
210 case RTE_CRYPTODEV_DPAA2_SEC_PMD:
211 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
217 static struct rte_mbuf *
218 setup_test_string(struct rte_mempool *mpool,
219 const uint8_t *data, size_t len, uint8_t blocksize)
221 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
222 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
225 char *dst = rte_pktmbuf_append(m, t_len);
232 rte_memcpy(dst, (const void *)data, t_len);
237 static struct crypto_testsuite_params testsuite_params = { NULL };
238 static struct crypto_unittest_params unittest_params;
239 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
242 testsuite_setup(void)
244 struct crypto_testsuite_params *ts_params = &testsuite_params;
245 struct rte_cryptodev_info info;
246 unsigned i, nb_devs, valid_dev_id = 0;
250 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
251 if (ts_params->mbuf_mp == NULL) {
252 /* Not already created so create */
253 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
254 "CRYPTO_PERF_MBUFPOOL",
255 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
257 if (ts_params->mbuf_mp == NULL) {
258 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
264 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
265 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
266 NUM_MBUFS, MBUF_CACHE_SIZE,
268 sizeof(struct rte_crypto_sym_xform) +
271 if (ts_params->op_mpool == NULL) {
272 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
276 /* Create an AESNI MB device if required */
277 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_MB_PMD) {
278 #ifndef RTE_LIBRTE_PMD_AESNI_MB
279 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
280 " enabled in config file to run this testsuite.\n");
283 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD);
286 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
288 TEST_ASSERT(ret == 0,
289 "Failed to create instance of pmd : %s",
290 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
294 /* Create an AESNI GCM device if required */
295 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_GCM_PMD) {
296 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
297 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
298 " enabled in config file to run this testsuite.\n");
301 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD);
304 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
306 TEST_ASSERT(ret == 0,
307 "Failed to create instance of pmd : %s",
308 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
312 /* Create a SNOW3G device if required */
313 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_SNOW3G_PMD) {
314 #ifndef RTE_LIBRTE_PMD_SNOW3G
315 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
316 " enabled in config file to run this testsuite.\n");
319 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
322 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
324 TEST_ASSERT(ret == 0,
325 "Failed to create instance of pmd : %s",
326 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
330 /* Create an OPENSSL device if required */
331 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_OPENSSL_PMD) {
332 #ifndef RTE_LIBRTE_PMD_OPENSSL
333 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
334 " enabled in config file to run this testsuite.\n");
337 nb_devs = rte_cryptodev_count_devtype(
338 RTE_CRYPTODEV_OPENSSL_PMD);
341 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
344 TEST_ASSERT(ret == 0, "Failed to create "
345 "instance of pmd : %s",
346 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
350 /* Create an ARMv8 device if required */
351 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_ARMV8_PMD) {
352 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
353 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
354 " enabled in config file to run this testsuite.\n");
357 nb_devs = rte_cryptodev_count_devtype(
358 RTE_CRYPTODEV_ARMV8_PMD);
361 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
364 TEST_ASSERT(ret == 0, "Failed to create "
365 "instance of pmd : %s",
366 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
370 #ifndef RTE_LIBRTE_PMD_QAT
371 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
372 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
373 "in config file to run this testsuite.\n");
378 nb_devs = rte_cryptodev_count();
380 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
384 /* Search for the first valid */
385 for (i = 0; i < nb_devs; i++) {
386 rte_cryptodev_info_get(i, &info);
387 if (info.dev_type == gbl_cryptodev_perftest_devtype) {
388 ts_params->dev_id = i;
398 * Using Crypto Device Id 0 by default.
399 * Set up all the qps on this device
402 rte_cryptodev_info_get(ts_params->dev_id, &info);
404 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
405 ts_params->conf.socket_id = SOCKET_ID_ANY;
406 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
408 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
410 "Failed to configure cryptodev %u",
413 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
414 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
416 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
417 ts_params->dev_id, qp_id,
419 rte_cryptodev_socket_id(ts_params->dev_id)),
420 "Failed to setup queue pair %u on cryptodev %u",
421 qp_id, ts_params->dev_id);
427 testsuite_teardown(void)
429 struct crypto_testsuite_params *ts_params =
432 if (ts_params->mbuf_mp != NULL)
433 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
434 rte_mempool_avail_count(ts_params->mbuf_mp));
435 if (ts_params->op_mpool != NULL)
436 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
437 rte_mempool_avail_count(ts_params->op_mpool));
443 struct crypto_testsuite_params *ts_params = &testsuite_params;
444 struct crypto_unittest_params *ut_params = &unittest_params;
446 /* Clear unit test parameters before running test */
447 memset(ut_params, 0, sizeof(*ut_params));
449 rte_cryptodev_stats_reset(ts_params->dev_id);
451 /* Start the device */
452 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
453 "Failed to start cryptodev %u",
462 struct crypto_testsuite_params *ts_params = &testsuite_params;
463 struct crypto_unittest_params *ut_params = &unittest_params;
464 struct rte_cryptodev_stats stats;
468 /* free crypto session structure */
470 rte_cryptodev_sym_session_free(ts_params->dev_id,
473 /* free crypto operation structure */
475 rte_crypto_op_free(ut_params->op);
477 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
478 if (ut_params->obuf[i])
479 rte_pktmbuf_free(ut_params->obuf[i]);
480 else if (ut_params->ibuf[i])
481 rte_pktmbuf_free(ut_params->ibuf[i]);
484 if (ts_params->mbuf_mp != NULL)
485 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
486 rte_mempool_avail_count(ts_params->mbuf_mp));
488 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
490 /* Stop the device */
491 rte_cryptodev_stop(ts_params->dev_id);
494 const char plaintext_quote[] =
495 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
496 "Marseilles--The Arrival. On the 24th of February, 1815, the "
497 "look-out at Notre-Dame de la Garde signalled the three-master,"
498 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
499 "pilot put off immediately, and rounding the Chateau d'If, got "
500 "on board the vessel between Cape Morgion and Rion island. "
501 "Immediately, and according to custom, the ramparts of Fort "
502 "Saint-Jean were covered with spectators; it is always an event "
503 "at Marseilles for a ship to come into port, especially when "
504 "this ship, like the Pharaon, has been built, rigged, and laden"
505 " at the old Phocee docks, and belongs to an owner of the city."
506 " The ship drew on and had safely passed the strait, which some"
507 " volcanic shock has made between the Calasareigne and Jaros "
508 "islands; had doubled Pomegue, and approached the harbor under"
509 " topsails, jib, and spanker, but so slowly and sedately that"
510 " the idlers, with that instinct which is the forerunner of "
511 "evil, asked one another what misfortune could have happened "
512 "on board. However, those experienced in navigation saw plainly"
513 " that if any accident had occurred, it was not to the vessel "
514 "herself, for she bore down with all the evidence of being "
515 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
516 "already eased off, and standing by the side of the pilot, who"
517 " was steering the Pharaon towards the narrow entrance of the"
518 " inner port, was a young man, who, with activity and vigilant"
519 " eye, watched every motion of the ship, and repeated each "
520 "direction of the pilot. The vague disquietude which prevailed "
521 "among the spectators had so much affected one of the crowd "
522 "that he did not await the arrival of the vessel in harbor, but"
523 " jumping into a small skiff, desired to be pulled alongside "
524 "the Pharaon, which he reached as she rounded into La Reserve "
525 "basin. When the young man on board saw this person approach, "
526 "he left his station by the pilot, and, hat in hand, leaned "
527 "over the ship's bulwarks. He was a fine, tall, slim young "
528 "fellow of eighteen or twenty, with black eyes, and hair as "
529 "dark as a raven's wing; and his whole appearance bespoke that "
530 "calmness and resolution peculiar to men accustomed from their "
531 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
532 "cried the man in the skiff. \"What's the matter? and why have "
533 "you such an air of sadness aboard?\" \"A great misfortune, M. "
534 "Morrel,\" replied the young man,--\"a great misfortune, for me"
535 " especially! Off Civita Vecchia we lost our brave Captain "
536 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
537 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
538 " that head. But poor Captain Leclere--\" \"What happened to "
539 "him?\" asked the owner, with an air of considerable "
540 "resignation. \"What happened to the worthy captain?\" \"He "
541 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
542 "brain-fever in dreadful agony.\" Then turning to the crew, "
543 "he said, \"Bear a hand there, to take in sail!\" All hands "
544 "obeyed, and at once the eight or ten seamen who composed the "
545 "crew, sprang to their respective stations at the spanker "
546 "brails and outhaul, topsail sheets and halyards, the jib "
547 "downhaul, and the topsail clewlines and buntlines. The young "
548 "sailor gave a look to see that his orders were promptly and "
549 "accurately obeyed, and then turned again to the owner. \"And "
550 "how did this misfortune occur?\" inquired the latter, resuming"
551 " the interrupted conversation. \"Alas, sir, in the most "
552 "unexpected manner. After a long talk with the harbor-master, "
553 "Captain Leclere left Naples greatly disturbed in mind. In "
554 "twenty-four hours he was attacked by a fever, and died three "
555 "days afterwards. We performed the usual burial service, and he"
556 " is at his rest, sewn up in his hammock with a thirty-six "
557 "pound shot at his head and his heels, off El Giglio island. "
558 "We bring to his widow his sword and cross of honor. It was "
559 "worth while, truly,\" added the young man with a melancholy "
560 "smile, \"to make war against the English for ten years, and "
561 "to die in his bed at last, like everybody else.";
563 #define QUOTE_LEN_64B (64)
564 #define QUOTE_LEN_128B (128)
565 #define QUOTE_LEN_256B (256)
566 #define QUOTE_LEN_512B (512)
567 #define QUOTE_LEN_768B (768)
568 #define QUOTE_LEN_1024B (1024)
569 #define QUOTE_LEN_1280B (1280)
570 #define QUOTE_LEN_1536B (1536)
571 #define QUOTE_LEN_1792B (1792)
572 #define QUOTE_LEN_2048B (2048)
575 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
577 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
579 #define CIPHER_KEY_LENGTH_AES_CBC (16)
580 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
582 static uint8_t aes_cbc_128_key[] = {
583 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
584 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
586 static uint8_t aes_cbc_128_iv[] = {
587 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
588 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
590 static uint8_t hmac_sha256_key[] = {
591 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
592 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
593 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
594 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
597 /* Cipher text output */
599 static const uint8_t AES_CBC_ciphertext_64B[] = {
600 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
601 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
602 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
603 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
604 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
605 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
606 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
607 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
610 static const uint8_t AES_CBC_ciphertext_128B[] = {
611 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
612 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
613 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
614 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
615 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
616 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
617 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
618 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
619 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
620 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
621 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
622 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
623 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
624 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
625 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
626 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
629 static const uint8_t AES_CBC_ciphertext_256B[] = {
630 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
631 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
632 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
633 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
634 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
635 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
636 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
637 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
638 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
639 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
640 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
641 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
642 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
643 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
644 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
645 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
646 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
647 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
648 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
649 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
650 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
651 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
652 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
653 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
654 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
655 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
656 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
657 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
658 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
659 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
660 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
661 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
664 static const uint8_t AES_CBC_ciphertext_512B[] = {
665 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
666 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
667 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
668 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
669 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
670 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
671 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
672 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
673 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
674 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
675 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
676 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
677 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
678 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
679 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
680 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
681 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
682 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
683 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
684 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
685 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
686 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
687 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
688 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
689 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
690 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
691 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
692 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
693 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
694 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
695 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
696 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
697 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
698 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
699 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
700 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
701 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
702 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
703 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
704 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
705 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
706 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
707 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
708 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
709 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
710 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
711 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
712 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
713 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
714 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
715 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
716 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
717 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
718 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
719 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
720 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
721 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
722 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
723 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
724 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
725 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
726 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
727 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
728 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
731 static const uint8_t AES_CBC_ciphertext_768B[] = {
732 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
733 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
734 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
735 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
736 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
737 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
738 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
739 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
740 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
741 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
742 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
743 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
744 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
745 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
746 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
747 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
748 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
749 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
750 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
751 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
752 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
753 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
754 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
755 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
756 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
757 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
758 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
759 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
760 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
761 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
762 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
763 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
764 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
765 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
766 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
767 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
768 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
769 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
770 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
771 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
772 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
773 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
774 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
775 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
776 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
777 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
778 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
779 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
780 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
781 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
782 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
783 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
784 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
785 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
786 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
787 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
788 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
789 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
790 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
791 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
792 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
793 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
794 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
795 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
796 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
797 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
798 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
799 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
800 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
801 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
802 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
803 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
804 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
805 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
806 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
807 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
808 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
809 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
810 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
811 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
812 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
813 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
814 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
815 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
816 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
817 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
818 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
819 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
820 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
821 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
822 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
823 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
824 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
825 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
826 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
827 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
830 static const uint8_t AES_CBC_ciphertext_1024B[] = {
831 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
832 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
833 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
834 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
835 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
836 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
837 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
838 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
839 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
840 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
841 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
842 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
843 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
844 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
845 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
846 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
847 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
848 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
849 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
850 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
851 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
852 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
853 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
854 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
855 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
856 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
857 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
858 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
859 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
860 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
861 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
862 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
863 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
864 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
865 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
866 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
867 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
868 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
869 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
870 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
871 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
872 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
873 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
874 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
875 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
876 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
877 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
878 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
879 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
880 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
881 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
882 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
883 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
884 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
885 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
886 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
887 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
888 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
889 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
890 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
891 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
892 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
893 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
894 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
895 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
896 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
897 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
898 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
899 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
900 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
901 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
902 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
903 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
904 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
905 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
906 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
907 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
908 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
909 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
910 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
911 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
912 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
913 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
914 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
915 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
916 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
917 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
918 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
919 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
920 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
921 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
922 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
923 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
924 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
925 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
926 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
927 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
928 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
929 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
930 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
931 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
932 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
933 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
934 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
935 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
936 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
937 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
938 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
939 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
940 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
941 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
942 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
943 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
944 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
945 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
946 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
947 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
948 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
949 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
950 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
951 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
952 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
953 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
954 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
955 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
956 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
957 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
958 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
961 static const uint8_t AES_CBC_ciphertext_1280B[] = {
962 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
963 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
964 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
965 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
966 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
967 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
968 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
969 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
970 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
971 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
972 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
973 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
974 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
975 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
976 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
977 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
978 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
979 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
980 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
981 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
982 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
983 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
984 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
985 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
986 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
987 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
988 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
989 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
990 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
991 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
992 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
993 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
994 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
995 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
996 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
997 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
998 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
999 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1000 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1001 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1002 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1003 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1004 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1005 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1006 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1007 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1008 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1009 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1010 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1011 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1012 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1013 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1014 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1015 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1016 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1017 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1018 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1019 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1020 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1021 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1022 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1023 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1024 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1025 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1026 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1027 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1028 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1029 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1030 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1031 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1032 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1033 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1034 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1035 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1036 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1037 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1038 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1039 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1040 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1041 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1042 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1043 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1044 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1045 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1046 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1047 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1048 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1049 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1050 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1051 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1052 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1053 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1054 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1055 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1056 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1057 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1058 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1059 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1060 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1061 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1062 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1063 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1064 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1065 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1066 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1067 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1068 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1069 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1070 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1071 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1072 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1073 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1074 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1075 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1076 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1077 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1078 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1079 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1080 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1081 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1082 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1083 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1084 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1085 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1086 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1087 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1088 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1089 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1090 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1091 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1092 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1093 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1094 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1095 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1096 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1097 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1098 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1099 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1100 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1101 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1102 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1103 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1104 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1105 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1106 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1107 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1108 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1109 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1110 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1111 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1112 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1113 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1114 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1115 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1116 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1117 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1118 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1119 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1120 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1121 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1124 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1125 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1126 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1127 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1128 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1129 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1130 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1131 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1132 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1133 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1134 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1135 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1136 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1137 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1138 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1139 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1140 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1141 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1142 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1143 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1144 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1145 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1146 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1147 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1148 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1149 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1150 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1151 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1152 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1153 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1154 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1155 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1156 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1157 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1158 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1159 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1160 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1161 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1162 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1163 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1164 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1165 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1166 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1167 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1168 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1169 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1170 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1171 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1172 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1173 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1174 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1175 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1176 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1177 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1178 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1179 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1180 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1181 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1182 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1183 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1184 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1185 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1186 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1187 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1188 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1189 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1190 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1191 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1192 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1193 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1194 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1195 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1196 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1197 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1198 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1199 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1200 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1201 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1202 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1203 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1204 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1205 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1206 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1207 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1208 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1209 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1210 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1211 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1212 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1213 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1214 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1215 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1216 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1217 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1218 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1219 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1220 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1221 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1222 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1223 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1224 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1225 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1226 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1227 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1228 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1229 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1230 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1231 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1232 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1233 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1234 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1235 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1236 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1237 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1238 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1239 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1240 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1241 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1242 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1243 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1244 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1245 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1246 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1247 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1248 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1249 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1250 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1251 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1252 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1253 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1254 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1255 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1256 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1257 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1258 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1259 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1260 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1261 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1262 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1263 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1264 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1265 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1266 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1267 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1268 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1269 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1270 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1271 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1272 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1273 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1274 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1275 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1276 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1277 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1278 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1279 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1280 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1281 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1282 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1283 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1284 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1285 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1286 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1287 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1288 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1289 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1290 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1291 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1292 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1293 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1294 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1295 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1296 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1297 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1298 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1299 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1300 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1301 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1302 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1303 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1304 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1305 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1306 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1307 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1308 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1309 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1310 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1311 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1312 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1313 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1314 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1315 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1316 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1319 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1320 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1321 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1322 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1323 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1324 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1325 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1326 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1327 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1328 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1329 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1330 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1331 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1332 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1333 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1334 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1335 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1336 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1337 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1338 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1339 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1340 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1341 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1342 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1343 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1344 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1345 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1346 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1347 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1348 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1349 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1350 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1351 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1352 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1353 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1354 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1355 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1356 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1357 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1358 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1359 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1360 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1361 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1362 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1363 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1364 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1365 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1366 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1367 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1368 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1369 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1370 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1371 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1372 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1373 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1374 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1375 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1376 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1377 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1378 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1379 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1380 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1381 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1382 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1383 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1384 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1385 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1386 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1387 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1388 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1389 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1390 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1391 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1392 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1393 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1394 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1395 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1396 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1397 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1398 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1399 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1400 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1401 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1402 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1403 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1404 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1405 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1406 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1407 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1408 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1409 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1410 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1411 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1412 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1413 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1414 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1415 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1416 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1417 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1418 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1419 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1420 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1421 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1422 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1423 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1424 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1425 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1426 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1427 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1428 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1429 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1430 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1431 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1432 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1433 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1434 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1435 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1436 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1437 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1438 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1439 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1440 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1441 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1442 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1443 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1444 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1445 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1446 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1447 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1448 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1449 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1450 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1451 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1452 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1453 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1454 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1455 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1456 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1457 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1458 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1459 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1460 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1461 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1462 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1463 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1464 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1465 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1466 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1467 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1468 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1469 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1470 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1471 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1472 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1473 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1474 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1475 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1476 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1477 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1478 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1479 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1480 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1481 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1482 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1483 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1484 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1485 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1486 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1487 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1488 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1489 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1490 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1491 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1492 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1493 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1494 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1495 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1496 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1497 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1498 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1499 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1500 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1501 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1502 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1503 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1504 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1505 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1506 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1507 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1508 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1509 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1510 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1511 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1512 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1513 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1514 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1515 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1516 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1517 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1518 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1519 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1520 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1521 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1522 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1523 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1524 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1525 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1526 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1527 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1528 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1529 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1530 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1531 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1532 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1533 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1534 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1535 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1536 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1537 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1538 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1539 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1540 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1541 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1542 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1543 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1546 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1547 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1548 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1549 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1550 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1551 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1552 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1553 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1554 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1555 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1556 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1557 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1558 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1559 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1560 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1561 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1562 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1563 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1564 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1565 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1566 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1567 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1568 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1569 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1570 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1571 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1572 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1573 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1574 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1575 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1576 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1577 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1578 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1579 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1580 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1581 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1582 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1583 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1584 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1585 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1586 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1587 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1588 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1589 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1590 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1591 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1592 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1593 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1594 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1595 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1596 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1597 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1598 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1599 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1600 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1601 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1602 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1603 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1604 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1605 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1606 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1607 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1608 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1609 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1610 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1611 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1612 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1613 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1614 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1615 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1616 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1617 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1618 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1619 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1620 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1621 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1622 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1623 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1624 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1625 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1626 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1627 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1628 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1629 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1630 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1631 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1632 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1633 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1634 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1635 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1636 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1637 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1638 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1639 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1640 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1641 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1642 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1643 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1644 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1645 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1646 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1647 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1648 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1649 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1650 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1651 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1652 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1653 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1654 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1655 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1656 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1657 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1658 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1659 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1660 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1661 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1662 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1663 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1664 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1665 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1666 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1667 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1668 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1669 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1670 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1671 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1672 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1673 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1674 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1675 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1676 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1677 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1678 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1679 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1680 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1681 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1682 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1683 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1684 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1685 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1686 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1687 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1688 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1689 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1690 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1691 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1692 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1693 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1694 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1695 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1696 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1697 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1698 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1699 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1700 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1701 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1702 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1703 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1704 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1705 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1706 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1707 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1708 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1709 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1710 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1711 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1712 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1713 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1714 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1715 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1716 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1717 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1718 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1719 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1720 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1721 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1722 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1723 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1724 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1725 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1726 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1727 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1728 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1729 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1730 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1731 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1732 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1733 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1734 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1735 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1736 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1737 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1738 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1739 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1740 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1741 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1742 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1743 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1744 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1745 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1746 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1747 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1748 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1749 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1750 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1751 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1752 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1753 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1754 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1755 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1756 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1757 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1758 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1759 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1760 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1761 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1762 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1763 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1764 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1765 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1766 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1767 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1768 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1769 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1770 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1771 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1772 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1773 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1774 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1775 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1776 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1777 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1778 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1779 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1780 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1781 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1782 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1783 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1784 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1785 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1786 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1787 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1788 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1789 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1790 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1791 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1792 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1793 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1794 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1795 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1796 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1797 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1798 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1799 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1800 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1801 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1802 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1806 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1807 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1808 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1809 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1810 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1813 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1814 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1815 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1816 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1817 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1820 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1821 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1822 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1823 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1824 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1827 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1828 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1829 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1830 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1831 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1834 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1835 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1836 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1837 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1838 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1841 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1842 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1843 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1844 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1845 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1848 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1849 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1850 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1851 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1852 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1855 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1856 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1857 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1858 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1859 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1862 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1863 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1864 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1865 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1866 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1869 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1870 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1871 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1872 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1873 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1876 struct crypto_data_params {
1879 const char *plaintext;
1880 struct crypto_expected_output {
1881 const uint8_t *ciphertext;
1882 const uint8_t *digest;
1886 #define MAX_PACKET_SIZE_INDEX 10
1888 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1889 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1890 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1891 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1892 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1893 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1894 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1895 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1896 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1897 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1898 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1899 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1900 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1901 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1902 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1903 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1904 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1905 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1906 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1907 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1908 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1912 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1914 uint32_t num_to_submit = 4096;
1915 struct rte_crypto_op *c_ops[num_to_submit];
1916 struct rte_crypto_op *proc_ops[num_to_submit];
1917 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1918 uint32_t burst_sent, burst_received;
1919 uint32_t i, burst_size, num_sent, num_received;
1920 struct crypto_testsuite_params *ts_params = &testsuite_params;
1921 struct crypto_unittest_params *ut_params = &unittest_params;
1922 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1924 if (rte_cryptodev_count() == 0) {
1925 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1929 /* Setup Cipher Parameters */
1930 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1931 ut_params->cipher_xform.next = &ut_params->auth_xform;
1933 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1934 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1935 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1936 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1937 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1938 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1940 /* Setup HMAC Parameters */
1941 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1942 ut_params->auth_xform.next = NULL;
1944 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1945 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1946 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1947 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1948 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1950 /* Create Crypto session*/
1951 ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
1952 &ut_params->cipher_xform);
1954 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1956 /* Generate Crypto op data structure(s) */
1957 for (i = 0; i < num_to_submit ; i++) {
1958 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
1959 data_params[0].expected.ciphertext,
1960 data_params[0].length, 0);
1961 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
1963 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
1964 DIGEST_BYTE_LENGTH_SHA256);
1965 TEST_ASSERT_NOT_NULL(ut_params->digest,
1966 "no room to append digest");
1968 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1969 DIGEST_BYTE_LENGTH_SHA256);
1972 struct rte_crypto_op *op =
1973 rte_crypto_op_alloc(ts_params->op_mpool,
1974 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1976 rte_crypto_op_attach_sym_session(op, ut_params->sess);
1978 op->sym->auth.digest.data = ut_params->digest;
1979 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
1980 data_params[0].length);
1982 op->sym->auth.data.offset = 0;
1983 op->sym->auth.data.length = data_params[0].length;
1985 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
1986 aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
1988 op->sym->cipher.data.offset = 0;
1989 op->sym->cipher.data.length = data_params[0].length;
1996 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
1997 "algorithm with a constant request size of %u.",
1998 data_params[0].length);
1999 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2000 "cost for each request.");
2001 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2002 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2003 "(assuming 0 retries)");
2004 for (i = 2; i <= 128 ; i *= 2) {
2011 while (num_sent < num_to_submit) {
2012 start_cycles = rte_rdtsc_precise();
2013 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2014 0, &c_ops[num_sent],
2015 ((num_to_submit-num_sent) < burst_size) ?
2016 num_to_submit-num_sent : burst_size);
2017 if (burst_sent == 0)
2020 num_sent += burst_sent;
2021 end_cycles = rte_rdtsc_precise();
2022 total_cycles += (end_cycles - start_cycles);
2024 * Wait until requests have been sent.
2028 start_cycles = rte_rdtsc_precise();
2029 burst_received = rte_cryptodev_dequeue_burst(
2030 dev_num, 0, proc_ops, burst_size);
2031 if (burst_received == 0)
2034 num_received += burst_received;
2035 end_cycles = rte_rdtsc_precise();
2036 total_cycles += end_cycles - start_cycles;
2039 while (num_received != num_to_submit) {
2040 if (gbl_cryptodev_perftest_devtype ==
2041 RTE_CRYPTODEV_AESNI_MB_PMD)
2042 rte_cryptodev_enqueue_burst(dev_num, 0,
2045 burst_received = rte_cryptodev_dequeue_burst(
2046 dev_num, 0, proc_ops, burst_size);
2047 if (burst_received == 0)
2050 num_received += burst_received;
2053 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2054 num_sent, num_received, burst_size);
2055 printf("\t\t%"PRIu64, retries);
2056 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2060 for (i = 0; i < num_to_submit ; i++) {
2061 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2062 rte_crypto_op_free(c_ops[i]);
2064 return TEST_SUCCESS;
2068 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2070 uint32_t num_to_submit = pparams->total_operations;
2071 struct rte_crypto_op *c_ops[num_to_submit];
2072 struct rte_crypto_op *proc_ops[num_to_submit];
2073 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2074 uint32_t burst_sent = 0, burst_received = 0;
2075 uint32_t i, burst_size, num_sent, num_ops_received;
2076 struct crypto_testsuite_params *ts_params = &testsuite_params;
2077 static struct rte_cryptodev_sym_session *sess;
2079 if (rte_cryptodev_count() == 0) {
2080 printf("\nNo crypto devices found. Is PMD build configured?\n");
2081 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2085 /* Create Crypto session*/
2086 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2087 pparams->chain, pparams->cipher_algo,
2088 pparams->cipher_key_length, pparams->auth_algo);
2089 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2091 /* Generate Crypto op data structure(s)*/
2092 for (i = 0; i < num_to_submit ; i++) {
2093 struct rte_mbuf *m = test_perf_create_pktmbuf(
2096 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2098 struct rte_crypto_op *op =
2099 rte_crypto_op_alloc(ts_params->op_mpool,
2100 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2101 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2103 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size);
2104 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2109 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2110 "Packet Size %u bytes",
2111 pmd_name(gbl_cryptodev_perftest_devtype),
2112 ts_params->dev_id, 0,
2113 chain_mode_name(pparams->chain),
2114 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2115 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2117 printf("\nOps Tx\tOps Rx\tOps/burst ");
2118 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2120 for (i = 2; i <= 128 ; i *= 2) {
2122 num_ops_received = 0;
2127 while (num_sent < num_to_submit) {
2128 start_cycles = rte_rdtsc_precise();
2129 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2130 0, &c_ops[num_sent],
2131 ((num_to_submit-num_sent) < burst_size) ?
2132 num_to_submit-num_sent : burst_size);
2133 end_cycles = rte_rdtsc_precise();
2134 if (burst_sent == 0)
2136 num_sent += burst_sent;
2137 total_cycles += (end_cycles - start_cycles);
2139 /* Wait until requests have been sent. */
2143 start_cycles = rte_rdtsc_precise();
2144 burst_received = rte_cryptodev_dequeue_burst(
2145 ts_params->dev_id, 0, proc_ops, burst_size);
2146 end_cycles = rte_rdtsc_precise();
2147 if (burst_received < burst_sent)
2149 num_ops_received += burst_received;
2151 total_cycles += end_cycles - start_cycles;
2154 while (num_ops_received != num_to_submit) {
2155 if (gbl_cryptodev_perftest_devtype ==
2156 RTE_CRYPTODEV_AESNI_MB_PMD)
2157 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2159 start_cycles = rte_rdtsc_precise();
2160 burst_received = rte_cryptodev_dequeue_burst(
2161 ts_params->dev_id, 0, proc_ops, burst_size);
2162 end_cycles = rte_rdtsc_precise();
2163 total_cycles += end_cycles - start_cycles;
2164 if (burst_received == 0)
2166 num_ops_received += burst_received;
2169 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2170 printf("\t\t%"PRIu64, retries);
2171 printf("\t%"PRIu64, failed_polls);
2172 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2173 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2174 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2178 for (i = 0; i < num_to_submit ; i++) {
2179 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2180 rte_crypto_op_free(c_ops[i]);
2182 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2184 return TEST_SUCCESS;
2188 test_perf_snow3G_vary_burst_size(void)
2190 unsigned total_operations = 4096;
2191 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2192 uint16_t buf_lengths[] = {40};
2195 struct perf_test_params params_set[] = {
2197 .chain = CIPHER_ONLY,
2198 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2199 .cipher_key_length = 16,
2200 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2204 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2205 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2206 .cipher_key_length = 16
2210 printf("\n\nStart %s.", __func__);
2211 printf("\nThis Test measures the average IA cycle cost using a "
2212 "constant request(packet) size. ");
2213 printf("Cycle cost is only valid when indicators show device is not busy,"
2214 " i.e. Retries and EmptyPolls = 0");
2216 for (i = 0; i < RTE_DIM(params_set); i++) {
2218 params_set[i].total_operations = total_operations;
2221 j < RTE_DIM(buf_lengths);
2224 params_set[i].buf_size = buf_lengths[j];
2226 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2235 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2237 uint32_t num_to_submit = pparams->total_operations;
2238 struct rte_crypto_op *c_ops[num_to_submit];
2239 struct rte_crypto_op *proc_ops[num_to_submit];
2240 uint64_t failed_polls, retries, start_cycles,
2241 end_cycles, total_cycles = 0;
2242 uint32_t burst_sent = 0, burst_received = 0;
2243 uint32_t i, burst_size, num_sent, num_ops_received;
2245 struct crypto_testsuite_params *ts_params = &testsuite_params;
2247 static struct rte_cryptodev_sym_session *sess;
2249 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2250 (struct rte_crypto_op *, struct rte_mbuf *,
2251 struct rte_cryptodev_sym_session *,
2255 if (rte_cryptodev_count() == 0) {
2256 printf("\nNo crypto devices found. Is PMD build configured?\n");
2260 /* Create Crypto session*/
2261 sess = test_perf_create_openssl_session(ts_params->dev_id,
2262 pparams->chain, pparams->cipher_algo,
2263 pparams->cipher_key_length, pparams->auth_algo);
2264 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2266 /* Generate Crypto op data structure(s)*/
2267 for (i = 0; i < num_to_submit ; i++) {
2268 struct rte_mbuf *m = test_perf_create_pktmbuf(
2271 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2273 struct rte_crypto_op *op =
2274 rte_crypto_op_alloc(ts_params->op_mpool,
2275 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2276 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2278 switch (pparams->cipher_algo) {
2279 case RTE_CRYPTO_CIPHER_3DES_CBC:
2280 case RTE_CRYPTO_CIPHER_3DES_CTR:
2281 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2283 case RTE_CRYPTO_CIPHER_AES_CBC:
2284 case RTE_CRYPTO_CIPHER_AES_CTR:
2285 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2287 case RTE_CRYPTO_CIPHER_AES_GCM:
2288 test_perf_set_crypto_op =
2289 test_perf_set_crypto_op_aes_gcm;
2295 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2297 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2302 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2303 "auth_algo:%s, Packet Size %u bytes",
2304 pmd_name(gbl_cryptodev_perftest_devtype),
2305 ts_params->dev_id, 0,
2306 chain_mode_name(pparams->chain),
2307 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2308 pparams->cipher_key_length,
2309 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2311 printf("\nOps Tx\tOps Rx\tOps/burst ");
2312 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2315 for (i = 2; i <= 128 ; i *= 2) {
2317 num_ops_received = 0;
2322 while (num_sent < num_to_submit) {
2323 start_cycles = rte_rdtsc_precise();
2324 burst_sent = rte_cryptodev_enqueue_burst(
2326 0, &c_ops[num_sent],
2327 ((num_to_submit - num_sent) <
2329 num_to_submit - num_sent : burst_size);
2330 end_cycles = rte_rdtsc_precise();
2331 if (burst_sent == 0)
2333 num_sent += burst_sent;
2334 total_cycles += (end_cycles - start_cycles);
2336 /* Wait until requests have been sent. */
2339 start_cycles = rte_rdtsc_precise();
2340 burst_received = rte_cryptodev_dequeue_burst(
2341 ts_params->dev_id, 0, proc_ops,
2343 end_cycles = rte_rdtsc_precise();
2344 if (burst_received < burst_sent)
2346 num_ops_received += burst_received;
2348 total_cycles += end_cycles - start_cycles;
2351 while (num_ops_received != num_to_submit) {
2352 /* Sending 0 length burst to flush sw crypto device */
2353 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2356 start_cycles = rte_rdtsc_precise();
2357 burst_received = rte_cryptodev_dequeue_burst(
2358 ts_params->dev_id, 0, proc_ops,
2360 end_cycles = rte_rdtsc_precise();
2362 total_cycles += end_cycles - start_cycles;
2363 if (burst_received == 0)
2365 num_ops_received += burst_received;
2368 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2369 printf("\t\t%"PRIu64, retries);
2370 printf("\t%"PRIu64, failed_polls);
2371 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2372 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2374 printf("\t\t%"PRIu64,
2376 (num_ops_received * pparams->buf_size));
2380 for (i = 0; i < num_to_submit ; i++) {
2381 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2382 rte_crypto_op_free(c_ops[i]);
2384 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2386 return TEST_SUCCESS;
2390 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2392 uint32_t num_to_submit = pparams->total_operations;
2393 struct rte_crypto_op *c_ops[num_to_submit];
2394 struct rte_crypto_op *proc_ops[num_to_submit];
2395 uint64_t failed_polls, retries, start_cycles, end_cycles,
2397 uint32_t burst_sent = 0, burst_received = 0;
2398 uint32_t i, burst_size, num_sent, num_ops_received;
2401 struct crypto_testsuite_params *ts_params = &testsuite_params;
2403 static struct rte_cryptodev_sym_session *sess;
2405 if (rte_cryptodev_count() == 0) {
2406 printf("\nNo crypto devices found. Is PMD build configured?\n");
2410 /* Create Crypto session*/
2411 sess = test_perf_create_armv8_session(ts_params->dev_id,
2412 pparams->chain, pparams->cipher_algo,
2413 pparams->cipher_key_length, pparams->auth_algo);
2414 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2416 /* Generate Crypto op data structure(s)*/
2417 for (i = 0; i < num_to_submit ; i++) {
2418 struct rte_mbuf *m = test_perf_create_pktmbuf(
2421 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2423 struct rte_crypto_op *op =
2424 rte_crypto_op_alloc(ts_params->op_mpool,
2425 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2426 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2428 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2430 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2435 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2436 "auth_algo:%s, Packet Size %u bytes",
2437 pmd_name(gbl_cryptodev_perftest_devtype),
2438 ts_params->dev_id, 0,
2439 chain_mode_name(pparams->chain),
2440 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2441 pparams->cipher_key_length,
2442 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2444 printf("\nOps Tx\tOps Rx\tOps/burst ");
2446 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2448 for (i = 2; i <= 128 ; i *= 2) {
2450 num_ops_received = 0;
2455 while (num_sent < num_to_submit) {
2456 if ((num_to_submit - num_sent) < burst_size)
2457 nb_ops = num_to_submit - num_sent;
2459 nb_ops = burst_size;
2461 start_cycles = rte_rdtsc();
2462 burst_sent = rte_cryptodev_enqueue_burst(
2464 0, &c_ops[num_sent],
2466 end_cycles = rte_rdtsc();
2468 if (burst_sent == 0)
2470 num_sent += burst_sent;
2471 total_cycles += (end_cycles - start_cycles);
2473 start_cycles = rte_rdtsc();
2474 burst_received = rte_cryptodev_dequeue_burst(
2475 ts_params->dev_id, 0, proc_ops,
2477 end_cycles = rte_rdtsc();
2478 if (burst_received < burst_sent)
2480 num_ops_received += burst_received;
2482 total_cycles += end_cycles - start_cycles;
2485 while (num_ops_received != num_to_submit) {
2486 /* Sending 0 length burst to flush sw crypto device */
2487 rte_cryptodev_enqueue_burst(
2488 ts_params->dev_id, 0, NULL, 0);
2490 start_cycles = rte_rdtsc();
2491 burst_received = rte_cryptodev_dequeue_burst(
2492 ts_params->dev_id, 0, proc_ops, burst_size);
2493 end_cycles = rte_rdtsc();
2495 total_cycles += end_cycles - start_cycles;
2496 if (burst_received == 0)
2498 num_ops_received += burst_received;
2501 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2502 printf("\t\t%"PRIu64, retries);
2503 printf("\t%"PRIu64, failed_polls);
2504 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2505 printf("\t\t%"PRIu64,
2506 (total_cycles/num_ops_received)*burst_size);
2507 printf("\t\t%"PRIu64,
2508 total_cycles/(num_ops_received*pparams->buf_size));
2512 for (i = 0; i < num_to_submit ; i++) {
2513 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2514 rte_crypto_op_free(c_ops[i]);
2517 return TEST_SUCCESS;
2520 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2523 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2525 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2527 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2529 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2531 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2533 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2535 case RTE_CRYPTO_AUTH_AES_GCM:
2542 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2545 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2547 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2548 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2549 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2550 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2551 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2552 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2553 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2554 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2555 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2556 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2557 case RTE_CRYPTO_AUTH_AES_GCM:
2558 return DIGEST_BYTE_LENGTH_AES_GCM;
2564 static uint8_t aes_key[] = {
2565 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2566 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2567 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2568 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2571 static uint8_t aes_iv[] = {
2572 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2576 static uint8_t aes_gcm_aad[] = {
2577 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2581 static uint8_t triple_des_key[] = {
2582 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2583 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2584 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2587 static uint8_t triple_des_iv[] = {
2588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2591 static uint8_t hmac_sha_key[] = {
2592 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2593 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2595 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2596 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2597 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2598 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2599 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2600 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2601 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2602 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2603 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2604 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2605 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2606 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2607 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2610 static uint8_t snow3g_cipher_key[] = {
2611 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2612 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2615 static uint8_t snow3g_iv[] = {
2616 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2617 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2620 static uint8_t snow3g_hash_key[] = {
2621 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2622 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2625 static struct rte_cryptodev_sym_session *
2626 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2627 enum rte_crypto_cipher_algorithm cipher_algo,
2628 unsigned cipher_key_len,
2629 enum rte_crypto_auth_algorithm auth_algo)
2631 struct rte_crypto_sym_xform cipher_xform = { 0 };
2632 struct rte_crypto_sym_xform auth_xform = { 0 };
2635 /* Setup Cipher Parameters */
2636 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2637 cipher_xform.cipher.algo = cipher_algo;
2638 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2640 cipher_xform.cipher.key.data = aes_key;
2641 cipher_xform.cipher.key.length = cipher_key_len;
2642 cipher_xform.cipher.iv.offset = IV_OFFSET;
2643 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2644 if (chain != CIPHER_ONLY) {
2645 /* Setup HMAC Parameters */
2646 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2647 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2648 auth_xform.auth.algo = auth_algo;
2649 auth_xform.auth.key.data = hmac_sha_key;
2650 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2651 auth_xform.auth.digest_length =
2652 get_auth_digest_length(auth_algo);
2656 cipher_xform.next = &auth_xform;
2657 auth_xform.next = NULL;
2658 /* Create Crypto session*/
2659 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2661 auth_xform.next = &cipher_xform;
2662 cipher_xform.next = NULL;
2663 /* Create Crypto session*/
2664 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2666 cipher_xform.next = NULL;
2667 /* Create Crypto session*/
2668 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2674 #define SNOW3G_CIPHER_IV_LENGTH 16
2676 static struct rte_cryptodev_sym_session *
2677 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2678 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2679 enum rte_crypto_auth_algorithm auth_algo)
2681 struct rte_crypto_sym_xform cipher_xform = {0};
2682 struct rte_crypto_sym_xform auth_xform = {0};
2685 /* Setup Cipher Parameters */
2686 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2687 cipher_xform.cipher.algo = cipher_algo;
2688 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2690 cipher_xform.cipher.key.data = snow3g_cipher_key;
2691 cipher_xform.cipher.key.length = cipher_key_len;
2692 cipher_xform.cipher.iv.offset = IV_OFFSET;
2693 cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2696 /* Setup HMAC Parameters */
2697 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2698 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2699 auth_xform.auth.algo = auth_algo;
2701 auth_xform.auth.key.data = snow3g_hash_key;
2702 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2703 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2704 /* Auth IV will be after cipher IV */
2705 auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
2706 auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2710 cipher_xform.next = &auth_xform;
2711 auth_xform.next = NULL;
2712 /* Create Crypto session*/
2713 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2715 auth_xform.next = &cipher_xform;
2716 cipher_xform.next = NULL;
2717 /* Create Crypto session*/
2718 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2720 cipher_xform.next = NULL;
2721 /* Create Crypto session*/
2722 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2724 auth_xform.next = NULL;
2725 /* Create Crypto session */
2726 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2732 static struct rte_cryptodev_sym_session *
2733 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2734 enum rte_crypto_cipher_algorithm cipher_algo,
2735 unsigned int cipher_key_len,
2736 enum rte_crypto_auth_algorithm auth_algo)
2738 struct rte_crypto_sym_xform cipher_xform = { 0 };
2739 struct rte_crypto_sym_xform auth_xform = { 0 };
2741 /* Setup Cipher Parameters */
2742 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2743 cipher_xform.cipher.algo = cipher_algo;
2744 cipher_xform.cipher.iv.offset = IV_OFFSET;
2745 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2747 switch (cipher_algo) {
2748 case RTE_CRYPTO_CIPHER_3DES_CBC:
2749 case RTE_CRYPTO_CIPHER_3DES_CTR:
2750 cipher_xform.cipher.key.data = triple_des_key;
2751 cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2753 case RTE_CRYPTO_CIPHER_AES_CBC:
2754 case RTE_CRYPTO_CIPHER_AES_CTR:
2755 case RTE_CRYPTO_CIPHER_AES_GCM:
2756 cipher_xform.cipher.key.data = aes_key;
2757 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2763 cipher_xform.cipher.key.length = cipher_key_len;
2765 /* Setup Auth Parameters */
2766 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2767 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2768 auth_xform.auth.algo = auth_algo;
2770 switch (auth_algo) {
2771 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2772 auth_xform.auth.key.data = hmac_sha_key;
2774 case RTE_CRYPTO_AUTH_AES_GCM:
2775 auth_xform.auth.key.data = NULL;
2776 auth_xform.auth.add_auth_data_length = AES_GCM_AAD_LENGTH;
2782 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2783 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2787 cipher_xform.next = &auth_xform;
2788 auth_xform.next = NULL;
2789 /* Create Crypto session*/
2790 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2792 auth_xform.next = &cipher_xform;
2793 cipher_xform.next = NULL;
2794 /* Create Crypto session*/
2795 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2801 static struct rte_cryptodev_sym_session *
2802 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2803 enum rte_crypto_cipher_algorithm cipher_algo,
2804 unsigned int cipher_key_len,
2805 enum rte_crypto_auth_algorithm auth_algo)
2807 struct rte_crypto_sym_xform cipher_xform = { 0 };
2808 struct rte_crypto_sym_xform auth_xform = { 0 };
2810 /* Setup Cipher Parameters */
2811 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2812 cipher_xform.cipher.algo = cipher_algo;
2814 switch (cipher_algo) {
2815 case RTE_CRYPTO_CIPHER_AES_CBC:
2816 cipher_xform.cipher.key.data = aes_cbc_128_key;
2822 cipher_xform.cipher.key.length = cipher_key_len;
2823 cipher_xform.cipher.iv.offset = IV_OFFSET;
2824 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2826 /* Setup Auth Parameters */
2827 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2828 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2829 auth_xform.auth.algo = auth_algo;
2831 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2835 cipher_xform.next = &auth_xform;
2836 auth_xform.next = NULL;
2837 /* Encrypt and hash the result */
2838 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2839 /* Create Crypto session*/
2840 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2842 auth_xform.next = &cipher_xform;
2843 cipher_xform.next = NULL;
2844 /* Hash encrypted message and decrypt */
2845 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2846 /* Create Crypto session*/
2847 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2853 static struct rte_mbuf *
2854 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2856 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2858 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2859 rte_pktmbuf_free(m);
2863 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2868 static inline struct rte_crypto_op *
2869 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2870 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2871 enum chain_mode chain)
2873 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2874 rte_crypto_op_free(op);
2878 /* Authentication Parameters */
2879 if (chain == CIPHER_ONLY) {
2880 op->sym->auth.digest.data = NULL;
2881 op->sym->auth.digest.phys_addr = 0;
2882 op->sym->auth.aad.data = NULL;
2883 op->sym->auth.data.offset = 0;
2884 op->sym->auth.data.length = 0;
2886 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2887 uint8_t *, data_len);
2888 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2890 op->sym->auth.data.offset = 0;
2891 op->sym->auth.data.length = data_len;
2895 /* Copy the IV at the end of the crypto operation */
2896 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2897 aes_iv, AES_CIPHER_IV_LENGTH);
2899 /* Cipher Parameters */
2900 op->sym->cipher.data.offset = 0;
2901 op->sym->cipher.data.length = data_len;
2908 static inline struct rte_crypto_op *
2909 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2910 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2911 enum chain_mode chain __rte_unused)
2913 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2914 rte_crypto_op_free(op);
2918 /* Authentication Parameters */
2919 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2920 (m->data_off + data_len);
2921 op->sym->auth.digest.phys_addr =
2922 rte_pktmbuf_mtophys_offset(m, data_len);
2923 op->sym->auth.aad.data = aes_gcm_aad;
2925 /* Copy IV at the end of the crypto operation */
2926 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2927 aes_iv, AES_CIPHER_IV_LENGTH);
2929 /* Data lengths/offsets Parameters */
2930 op->sym->auth.data.offset = 0;
2931 op->sym->auth.data.length = data_len;
2933 op->sym->cipher.data.offset = 0;
2934 op->sym->cipher.data.length = data_len;
2941 static inline struct rte_crypto_op *
2942 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2943 struct rte_cryptodev_sym_session *sess, unsigned int data_len)
2945 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
2946 uint8_t *, IV_OFFSET);
2948 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2949 rte_crypto_op_free(op);
2953 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2955 /* Authentication Parameters */
2956 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2957 (m->data_off + data_len);
2958 op->sym->auth.digest.phys_addr =
2959 rte_pktmbuf_mtophys_offset(m, data_len);
2961 /* Data lengths/offsets Parameters */
2962 op->sym->auth.data.offset = 0;
2963 op->sym->auth.data.length = data_len << 3;
2965 op->sym->cipher.data.offset = 0;
2966 op->sym->cipher.data.length = data_len << 3;
2973 static inline struct rte_crypto_op *
2974 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2976 struct rte_cryptodev_sym_session *sess,
2979 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2980 rte_crypto_op_free(op);
2984 /* Copy IV at the end of the crypto operation */
2985 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2986 snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2988 /* Cipher Parameters */
2989 op->sym->cipher.data.offset = 0;
2990 op->sym->cipher.data.length = data_len << 3;
2992 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2994 SNOW3G_CIPHER_IV_LENGTH);
3002 static inline struct rte_crypto_op *
3003 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3005 struct rte_cryptodev_sym_session *sess,
3006 unsigned int data_len)
3008 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3009 uint8_t *, IV_OFFSET);
3011 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3012 rte_crypto_op_free(op);
3016 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3018 /* Authentication Parameters */
3020 op->sym->auth.digest.data =
3021 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3023 op->sym->auth.digest.phys_addr =
3024 rte_pktmbuf_mtophys_offset(m, data_len +
3025 SNOW3G_CIPHER_IV_LENGTH);
3027 /* Data lengths/offsets Parameters */
3028 op->sym->auth.data.offset = 0;
3029 op->sym->auth.data.length = data_len << 3;
3037 static inline struct rte_crypto_op *
3038 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3039 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3040 enum chain_mode chain __rte_unused)
3042 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3043 rte_crypto_op_free(op);
3047 /* Authentication Parameters */
3048 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3049 (m->data_off + data_len);
3050 op->sym->auth.digest.phys_addr =
3051 rte_pktmbuf_mtophys_offset(m, data_len);
3053 /* Copy IV at the end of the crypto operation */
3054 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3055 triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3057 /* Data lengths/offsets Parameters */
3058 op->sym->auth.data.offset = 0;
3059 op->sym->auth.data.length = data_len;
3061 op->sym->cipher.data.offset = 0;
3062 op->sym->cipher.data.length = data_len;
3069 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3070 * same time, i.e. as they're not dereferenced there's no need to wait until
3071 * finished with to re-use */
3072 #define NUM_MBUF_SETS 8
3075 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3076 struct perf_test_params *pparams)
3078 uint16_t i, k, l, m;
3080 uint16_t ops_unused = 0;
3082 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3083 uint64_t processed = 0, failed_polls = 0, retries = 0;
3084 uint64_t tsc_start = 0, tsc_end = 0;
3086 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3088 struct rte_crypto_op *ops[pparams->burst_size];
3089 struct rte_crypto_op *proc_ops[pparams->burst_size];
3091 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3093 struct crypto_testsuite_params *ts_params = &testsuite_params;
3095 static struct rte_cryptodev_sym_session *sess;
3097 if (rte_cryptodev_count() == 0) {
3098 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3102 /* Create Crypto session*/
3103 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3104 pparams->chain, pparams->cipher_algo,
3105 pparams->cipher_key_length, pparams->auth_algo);
3106 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3108 /* Generate a burst of crypto operations */
3109 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3110 mbufs[i] = test_perf_create_pktmbuf(
3114 if (mbufs[i] == NULL) {
3115 printf("\nFailed to get mbuf - freeing the rest.\n");
3116 for (k = 0; k < i; k++)
3117 rte_pktmbuf_free(mbufs[k]);
3121 /* Make room for Digest in mbuf */
3122 if (pparams->chain != CIPHER_ONLY)
3123 rte_pktmbuf_append(mbufs[i], digest_length);
3127 tsc_start = rte_rdtsc_precise();
3129 while (total_enqueued < pparams->total_operations) {
3130 uint16_t burst_size =
3131 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3132 pparams->burst_size : pparams->total_operations-total_enqueued;
3133 uint16_t ops_needed = burst_size-ops_unused;
3135 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3136 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3137 printf("\nFailed to alloc enough ops, finish dequeuing "
3138 "and free ops below.");
3140 for (i = 0; i < ops_needed; i++)
3141 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3142 mbufs[i + (pparams->burst_size *
3143 (j % NUM_MBUF_SETS))],
3144 sess, pparams->buf_size,
3148 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3149 queue_id, ops, burst_size);
3151 if (burst_enqueued < burst_size)
3154 ops_unused = burst_size-burst_enqueued;
3155 total_enqueued += burst_enqueued;
3159 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3160 proc_ops, pparams->burst_size);
3161 if (burst_dequeued == 0)
3164 processed += burst_dequeued;
3166 for (l = 0; l < burst_dequeued; l++)
3167 rte_crypto_op_free(proc_ops[l]);
3172 /* Dequeue any operations still in the crypto device */
3173 while (processed < pparams->total_operations) {
3174 /* Sending 0 length burst to flush sw crypto device */
3175 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3178 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3179 proc_ops, pparams->burst_size);
3180 if (burst_dequeued == 0)
3183 processed += burst_dequeued;
3185 for (m = 0; m < burst_dequeued; m++)
3186 rte_crypto_op_free(proc_ops[m]);
3190 tsc_end = rte_rdtsc_precise();
3192 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3193 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3195 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3196 throughput, retries, failed_polls);
3198 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3199 rte_pktmbuf_free(mbufs[i]);
3200 rte_cryptodev_sym_session_free(dev_id, sess);
3203 return TEST_SUCCESS;
3208 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3209 struct perf_test_params *pparams)
3211 uint16_t i, k, l, m;
3213 uint16_t ops_unused = 0;
3214 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3215 uint64_t processed = 0, failed_polls = 0, retries = 0;
3216 uint64_t tsc_start = 0, tsc_end = 0;
3218 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3220 struct rte_crypto_op *ops[pparams->burst_size];
3221 struct rte_crypto_op *proc_ops[pparams->burst_size];
3223 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3225 struct crypto_testsuite_params *ts_params = &testsuite_params;
3227 static struct rte_cryptodev_sym_session *sess;
3229 if (rte_cryptodev_count() == 0) {
3230 printf("\nNo crypto devices found. Is PMD build configured?\n");
3231 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3235 /* Create Crypto session*/
3236 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3237 pparams->chain, pparams->cipher_algo,
3238 pparams->cipher_key_length, pparams->auth_algo);
3239 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3241 /* Generate a burst of crypto operations */
3242 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3244 * Buffer size is allocated, for perf tests they
3245 * are equal + digest len.
3247 mbufs[i] = test_perf_create_pktmbuf(
3252 if (mbufs[i] == NULL) {
3253 printf("\nFailed to get mbuf - freeing the rest.\n");
3254 for (k = 0; k < i; k++)
3255 rte_pktmbuf_free(mbufs[k]);
3261 tsc_start = rte_rdtsc_precise();
3263 while (total_enqueued < pparams->total_operations) {
3264 uint16_t burst_size =
3265 (total_enqueued+pparams->burst_size)
3266 <= pparams->total_operations ?
3267 pparams->burst_size : pparams->total_operations-total_enqueued;
3268 uint16_t ops_needed = burst_size-ops_unused;
3269 /* Handle the last burst correctly */
3270 uint16_t op_offset = pparams->burst_size - burst_size;
3273 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3274 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3275 ops+op_offset, ops_needed)) {
3276 printf("\nFailed to alloc enough ops.");
3277 /*Don't exit, dequeue, more ops should become available*/
3279 for (i = 0; i < ops_needed; i++) {
3280 if (pparams->chain == HASH_ONLY)
3282 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3284 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3287 else if (pparams->chain == CIPHER_ONLY)
3289 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3291 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3300 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3301 ops+op_offset, burst_size);
3303 if (burst_enqueued < burst_size)
3306 ops_unused = burst_size-burst_enqueued;
3307 total_enqueued += burst_enqueued;
3311 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3312 proc_ops, pparams->burst_size);
3313 if (burst_dequeued == 0) {
3316 processed += burst_dequeued;
3317 for (l = 0; l < burst_dequeued; l++)
3318 rte_crypto_op_free(proc_ops[l]);
3323 /* Dequeue any operations still in the crypto device */
3324 while (processed < pparams->total_operations) {
3325 /* Sending 0 length burst to flush sw crypto device */
3326 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3329 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3330 proc_ops, pparams->burst_size);
3331 if (burst_dequeued == 0)
3334 processed += burst_dequeued;
3335 for (m = 0; m < burst_dequeued; m++)
3336 rte_crypto_op_free(proc_ops[m]);
3340 tsc_end = rte_rdtsc_precise();
3342 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3343 double cycles_burst = (double) (tsc_end - tsc_start) /
3344 (double) processed * pparams->burst_size;
3345 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3346 double cycles_B = cycles_buff / pparams->buf_size;
3347 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3349 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3350 /* Cycle count misleading on HW devices for this test, so don't print */
3351 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3352 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3353 pparams->buf_size, ops_s/1000000,
3354 throughput, retries, failed_polls);
3356 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3357 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3358 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3359 cycles_buff, cycles_B, retries, failed_polls);
3362 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3363 rte_pktmbuf_free(mbufs[i]);
3364 rte_cryptodev_sym_session_free(dev_id, sess);
3367 return TEST_SUCCESS;
3371 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3372 struct perf_test_params *pparams)
3374 uint16_t i, k, l, m;
3376 uint16_t ops_unused = 0;
3378 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3379 uint64_t processed = 0, failed_polls = 0, retries = 0;
3380 uint64_t tsc_start = 0, tsc_end = 0;
3382 struct rte_crypto_op *ops[pparams->burst_size];
3383 struct rte_crypto_op *proc_ops[pparams->burst_size];
3385 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3387 struct crypto_testsuite_params *ts_params = &testsuite_params;
3389 static struct rte_cryptodev_sym_session *sess;
3391 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3392 (struct rte_crypto_op *, struct rte_mbuf *,
3393 struct rte_cryptodev_sym_session *,
3397 switch (pparams->cipher_algo) {
3398 case RTE_CRYPTO_CIPHER_3DES_CBC:
3399 case RTE_CRYPTO_CIPHER_3DES_CTR:
3400 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3402 case RTE_CRYPTO_CIPHER_AES_CBC:
3403 case RTE_CRYPTO_CIPHER_AES_CTR:
3404 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3406 case RTE_CRYPTO_CIPHER_AES_GCM:
3407 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3413 if (rte_cryptodev_count() == 0) {
3414 printf("\nNo crypto devices found. Is PMD build configured?\n");
3418 /* Create Crypto session*/
3419 sess = test_perf_create_openssl_session(ts_params->dev_id,
3420 pparams->chain, pparams->cipher_algo,
3421 pparams->cipher_key_length, pparams->auth_algo);
3422 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3424 /* Generate a burst of crypto operations */
3425 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3426 mbufs[i] = test_perf_create_pktmbuf(
3430 if (mbufs[i] == NULL) {
3431 printf("\nFailed to get mbuf - freeing the rest.\n");
3432 for (k = 0; k < i; k++)
3433 rte_pktmbuf_free(mbufs[k]);
3438 tsc_start = rte_rdtsc_precise();
3440 while (total_enqueued < pparams->total_operations) {
3441 uint16_t burst_size =
3442 total_enqueued + pparams->burst_size <=
3443 pparams->total_operations ? pparams->burst_size :
3444 pparams->total_operations - total_enqueued;
3445 uint16_t ops_needed = burst_size - ops_unused;
3447 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3448 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3449 printf("\nFailed to alloc enough ops, finish dequeuing "
3450 "and free ops below.");
3452 for (i = 0; i < ops_needed; i++)
3453 ops[i] = test_perf_set_crypto_op(ops[i],
3454 mbufs[i + (pparams->burst_size *
3455 (j % NUM_MBUF_SETS))],
3456 sess, pparams->buf_size,
3460 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3461 queue_id, ops, burst_size);
3463 if (burst_enqueued < burst_size)
3466 ops_unused = burst_size - burst_enqueued;
3467 total_enqueued += burst_enqueued;
3471 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3472 proc_ops, pparams->burst_size);
3473 if (burst_dequeued == 0)
3476 processed += burst_dequeued;
3478 for (l = 0; l < burst_dequeued; l++)
3479 rte_crypto_op_free(proc_ops[l]);
3484 /* Dequeue any operations still in the crypto device */
3485 while (processed < pparams->total_operations) {
3486 /* Sending 0 length burst to flush sw crypto device */
3487 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3490 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3491 proc_ops, pparams->burst_size);
3492 if (burst_dequeued == 0)
3495 processed += burst_dequeued;
3497 for (m = 0; m < burst_dequeued; m++)
3498 rte_crypto_op_free(proc_ops[m]);
3502 tsc_end = rte_rdtsc_precise();
3504 double ops_s = ((double)processed / (tsc_end - tsc_start))
3506 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3509 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3510 ops_s / 1000000, throughput, retries, failed_polls);
3512 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3513 rte_pktmbuf_free(mbufs[i]);
3514 rte_cryptodev_sym_session_free(dev_id, sess);
3517 return TEST_SUCCESS;
3521 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3522 struct perf_test_params *pparams)
3524 uint16_t i, k, l, m;
3526 uint16_t ops_unused = 0;
3527 uint16_t burst_size;
3528 uint16_t ops_needed;
3530 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3531 uint64_t processed = 0, failed_polls = 0, retries = 0;
3532 uint64_t tsc_start = 0, tsc_end = 0;
3534 struct rte_crypto_op *ops[pparams->burst_size];
3535 struct rte_crypto_op *proc_ops[pparams->burst_size];
3537 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3539 struct crypto_testsuite_params *ts_params = &testsuite_params;
3541 static struct rte_cryptodev_sym_session *sess;
3543 if (rte_cryptodev_count() == 0) {
3544 printf("\nNo crypto devices found. Is PMD build configured?\n");
3548 /* Create Crypto session*/
3549 sess = test_perf_create_armv8_session(ts_params->dev_id,
3550 pparams->chain, pparams->cipher_algo,
3551 pparams->cipher_key_length, pparams->auth_algo);
3552 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3554 /* Generate a burst of crypto operations */
3555 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3556 mbufs[i] = test_perf_create_pktmbuf(
3560 if (mbufs[i] == NULL) {
3561 printf("\nFailed to get mbuf - freeing the rest.\n");
3562 for (k = 0; k < i; k++)
3563 rte_pktmbuf_free(mbufs[k]);
3568 tsc_start = rte_rdtsc();
3570 while (total_enqueued < pparams->total_operations) {
3571 if ((total_enqueued + pparams->burst_size) <=
3572 pparams->total_operations)
3573 burst_size = pparams->burst_size;
3575 burst_size = pparams->total_operations - total_enqueued;
3577 ops_needed = burst_size - ops_unused;
3579 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3580 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3581 printf("\nFailed to alloc enough ops, finish dequeuing "
3582 "and free ops below.");
3584 for (i = 0; i < ops_needed; i++)
3585 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3586 mbufs[i + (pparams->burst_size *
3587 (j % NUM_MBUF_SETS))], sess,
3592 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3593 queue_id, ops, burst_size);
3595 if (burst_enqueued < burst_size)
3598 ops_unused = burst_size - burst_enqueued;
3599 total_enqueued += burst_enqueued;
3603 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3604 proc_ops, pparams->burst_size);
3605 if (burst_dequeued == 0)
3608 processed += burst_dequeued;
3610 for (l = 0; l < burst_dequeued; l++)
3611 rte_crypto_op_free(proc_ops[l]);
3616 /* Dequeue any operations still in the crypto device */
3617 while (processed < pparams->total_operations) {
3618 /* Sending 0 length burst to flush sw crypto device */
3619 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3622 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3623 proc_ops, pparams->burst_size);
3624 if (burst_dequeued == 0)
3627 processed += burst_dequeued;
3629 for (m = 0; m < burst_dequeued; m++)
3630 rte_crypto_op_free(proc_ops[m]);
3634 tsc_end = rte_rdtsc();
3636 double ops_s = ((double)processed / (tsc_end - tsc_start))
3638 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3641 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3642 ops_s / 1000000, throughput, retries, failed_polls);
3644 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3645 rte_pktmbuf_free(mbufs[i]);
3648 return TEST_SUCCESS;
3653 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3654 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3655 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3657 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3658 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3659 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3661 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3662 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3663 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3666 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3668 unsigned total_operations = 1000000;
3669 unsigned burst_size = 32;
3670 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3673 struct perf_test_params params_set[] = {
3675 .chain = CIPHER_ONLY,
3676 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3677 .cipher_key_length = 16,
3678 .auth_algo = RTE_CRYPTO_AUTH_NULL
3681 .chain = CIPHER_HASH,
3682 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3683 .cipher_key_length = 16,
3684 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3687 .chain = CIPHER_HASH,
3689 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3690 .cipher_key_length = 16,
3691 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3694 .chain = CIPHER_HASH,
3696 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3697 .cipher_key_length = 16,
3698 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3701 .chain = CIPHER_HASH,
3703 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3704 .cipher_key_length = 32,
3705 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3708 .chain = CIPHER_HASH,
3710 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3711 .cipher_key_length = 32,
3712 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3715 .chain = CIPHER_HASH,
3717 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3718 .cipher_key_length = 32,
3719 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3723 for (i = 0; i < RTE_DIM(params_set); i++) {
3725 params_set[i].total_operations = total_operations;
3726 params_set[i].burst_size = burst_size;
3727 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3728 " burst_size: %d ops\n",
3729 chain_mode_name(params_set[i].chain),
3730 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3731 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3732 params_set[i].cipher_key_length,
3734 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3735 "Retries\tEmptyPolls\n");
3736 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3737 params_set[i].buf_size = buf_lengths[j];
3738 test_perf_aes_sha(testsuite_params.dev_id, 0,
3746 test_perf_snow3G_vary_pkt_size(void)
3748 unsigned total_operations = 1000000;
3751 uint16_t burst_sizes[] = { 64 };
3752 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3754 struct perf_test_params params_set[] = {
3756 .chain = CIPHER_ONLY,
3757 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3758 .cipher_key_length = 16,
3759 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3763 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3764 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3765 .cipher_key_length = 16
3769 printf("\n\nStart %s.", __func__);
3770 printf("\nTest to measure max throughput at various pkt sizes.");
3771 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3772 " so cycle cost not relevant (n/a displayed).");
3774 for (i = 0; i < RTE_DIM(params_set); i++) {
3776 params_set[i].total_operations = total_operations;
3777 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3778 enum rte_crypto_cipher_algorithm cipher_algo =
3779 params_set[i].cipher_algo;
3780 enum rte_crypto_auth_algorithm auth_algo =
3781 params_set[i].auth_algo;
3782 printf("\nOn %s dev%u qp%u, %s, "
3783 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3784 pmd_name(gbl_cryptodev_perftest_devtype),
3785 testsuite_params.dev_id, 0,
3786 chain_mode_name(params_set[i].chain),
3787 rte_crypto_cipher_algorithm_strings[cipher_algo],
3788 rte_crypto_auth_algorithm_strings[auth_algo],
3791 params_set[i].burst_size = burst_sizes[k];
3792 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3793 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3794 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3796 params_set[i].buf_size = buf_lengths[j];
3798 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3807 test_perf_openssl_vary_pkt_size(void)
3809 unsigned int total_operations = 10000;
3810 unsigned int burst_size = { 64 };
3811 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3815 struct perf_test_params params_set[] = {
3817 .chain = CIPHER_HASH,
3819 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3820 .cipher_key_length = 16,
3821 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3824 .chain = CIPHER_HASH,
3826 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3827 .cipher_key_length = 24,
3828 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3831 .chain = CIPHER_HASH,
3833 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3834 .cipher_key_length = 16,
3835 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3838 .chain = CIPHER_HASH,
3840 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3841 .cipher_key_length = 32,
3842 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3845 .chain = CIPHER_HASH,
3847 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3848 .cipher_key_length = 16,
3849 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3852 .chain = CIPHER_HASH,
3854 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3855 .cipher_key_length = 24,
3856 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3859 .chain = CIPHER_HASH,
3861 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3862 .cipher_key_length = 16,
3863 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3867 for (i = 0; i < RTE_DIM(params_set); i++) {
3868 params_set[i].total_operations = total_operations;
3869 params_set[i].burst_size = burst_size;
3870 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3871 " burst_size: %d ops\n",
3872 chain_mode_name(params_set[i].chain),
3873 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3874 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3875 params_set[i].cipher_key_length,
3877 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3879 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3880 params_set[i].buf_size = buf_lengths[j];
3881 test_perf_openssl(testsuite_params.dev_id, 0,
3890 test_perf_openssl_vary_burst_size(void)
3892 unsigned int total_operations = 4096;
3893 uint16_t buf_lengths[] = { 40 };
3896 struct perf_test_params params_set[] = {
3898 .chain = CIPHER_HASH,
3900 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3901 .cipher_key_length = 16,
3902 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3905 .chain = CIPHER_HASH,
3907 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3908 .cipher_key_length = 24,
3909 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3912 .chain = CIPHER_HASH,
3914 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3915 .cipher_key_length = 16,
3916 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3919 .chain = CIPHER_HASH,
3921 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3922 .cipher_key_length = 32,
3923 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3926 .chain = CIPHER_HASH,
3928 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3929 .cipher_key_length = 16,
3930 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3933 .chain = CIPHER_HASH,
3935 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3936 .cipher_key_length = 24,
3937 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3940 .chain = CIPHER_HASH,
3942 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3943 .cipher_key_length = 16,
3944 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3948 printf("\n\nStart %s.", __func__);
3949 printf("\nThis Test measures the average IA cycle cost using a "
3950 "constant request(packet) size. ");
3951 printf("Cycle cost is only valid when indicators show device is not"
3952 " busy, i.e. Retries and EmptyPolls = 0");
3954 for (i = 0; i < RTE_DIM(params_set); i++) {
3956 params_set[i].total_operations = total_operations;
3958 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3959 params_set[i].buf_size = buf_lengths[j];
3960 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3968 test_perf_armv8_vary_pkt_size(void)
3970 unsigned int total_operations = 100000;
3971 unsigned int burst_size = { 64 };
3972 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3976 struct perf_test_params params_set[] = {
3978 .chain = CIPHER_HASH,
3980 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3981 .cipher_key_length = 16,
3982 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3985 .chain = HASH_CIPHER,
3987 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3988 .cipher_key_length = 16,
3989 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3992 .chain = CIPHER_HASH,
3994 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3995 .cipher_key_length = 16,
3996 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3999 .chain = HASH_CIPHER,
4001 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4002 .cipher_key_length = 16,
4003 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4007 for (i = 0; i < RTE_DIM(params_set); i++) {
4008 params_set[i].total_operations = total_operations;
4009 params_set[i].burst_size = burst_size;
4010 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4011 " burst_size: %d ops\n",
4012 chain_mode_name(params_set[i].chain),
4013 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4014 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4015 params_set[i].cipher_key_length,
4017 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4019 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4020 params_set[i].buf_size = buf_lengths[j];
4021 test_perf_armv8(testsuite_params.dev_id, 0,
4030 test_perf_armv8_vary_burst_size(void)
4032 unsigned int total_operations = 4096;
4033 uint16_t buf_lengths[] = { 64 };
4036 struct perf_test_params params_set[] = {
4038 .chain = CIPHER_HASH,
4040 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4041 .cipher_key_length = 16,
4042 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4045 .chain = HASH_CIPHER,
4047 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4048 .cipher_key_length = 16,
4049 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4052 .chain = CIPHER_HASH,
4054 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4055 .cipher_key_length = 16,
4056 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4059 .chain = HASH_CIPHER,
4061 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4062 .cipher_key_length = 16,
4063 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4067 printf("\n\nStart %s.", __func__);
4068 printf("\nThis Test measures the average IA cycle cost using a "
4069 "constant request(packet) size. ");
4070 printf("Cycle cost is only valid when indicators show device is "
4071 "not busy, i.e. Retries and EmptyPolls = 0");
4073 for (i = 0; i < RTE_DIM(params_set); i++) {
4075 params_set[i].total_operations = total_operations;
4077 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4078 params_set[i].buf_size = buf_lengths[j];
4079 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4087 test_perf_aes_cbc_vary_burst_size(void)
4089 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4093 static struct rte_cryptodev_sym_session *
4094 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4096 static struct rte_cryptodev_sym_session *sess;
4097 struct rte_crypto_sym_xform cipher_xform = { 0 };
4098 struct rte_crypto_sym_xform auth_xform = { 0 };
4100 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4101 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4103 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4104 pparams->session_attrs->key_cipher_len);
4105 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4106 pparams->session_attrs->key_auth_len);
4108 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4109 cipher_xform.next = NULL;
4111 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4112 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4113 cipher_xform.cipher.key.data = cipher_key;
4114 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4115 cipher_xform.cipher.iv.length = pparams->session_attrs->iv_len;
4116 cipher_xform.cipher.iv.offset = IV_OFFSET;
4118 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4119 auth_xform.next = NULL;
4121 auth_xform.auth.op = pparams->session_attrs->auth;
4122 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4124 auth_xform.auth.add_auth_data_length = pparams->session_attrs->aad_len;
4125 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4126 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4129 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4130 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4131 cipher_xform.next = &auth_xform;
4132 sess = rte_cryptodev_sym_session_create(dev_id,
4135 auth_xform.next = &cipher_xform;
4136 sess = rte_cryptodev_sym_session_create(dev_id,
4143 static inline struct rte_crypto_op *
4144 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4145 struct rte_cryptodev_sym_session *sess,
4146 struct crypto_params *m_hlp,
4147 struct perf_test_params *params)
4149 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4150 uint8_t *, IV_OFFSET);
4152 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4153 rte_crypto_op_free(op);
4157 op->sym->auth.digest.data = m_hlp->digest;
4158 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4160 params->session_attrs->aad_len +
4161 params->symmetric_op->p_len);
4164 op->sym->auth.aad.data = m_hlp->aad;
4165 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
4167 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4168 params->session_attrs->aad_len);
4170 rte_memcpy(iv_ptr, params->session_attrs->iv_data,
4171 params->session_attrs->iv_len);
4172 if (params->session_attrs->iv_len == 12)
4175 op->sym->auth.data.offset =
4176 params->session_attrs->aad_len;
4177 op->sym->auth.data.length = params->symmetric_op->p_len;
4179 op->sym->cipher.data.offset =
4180 params->session_attrs->aad_len;
4181 op->sym->cipher.data.length = params->symmetric_op->p_len;
4188 static struct rte_mbuf *
4189 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4190 struct perf_test_params *params,
4191 unsigned buf_sz, struct crypto_params *m_hlp)
4193 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4194 uint16_t aad_len = params->session_attrs->aad_len;
4195 uint16_t digest_size = params->symmetric_op->t_len;
4198 p = rte_pktmbuf_append(m, aad_len);
4200 rte_pktmbuf_free(m);
4203 m_hlp->aad = (uint8_t *)p;
4205 p = rte_pktmbuf_append(m, buf_sz);
4207 rte_pktmbuf_free(m);
4210 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4212 p = rte_pktmbuf_append(m, digest_size);
4214 rte_pktmbuf_free(m);
4217 m_hlp->digest = (uint8_t *)p;
4223 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4224 struct perf_test_params *pparams, uint32_t test_ops)
4227 struct crypto_testsuite_params *ts_params = &testsuite_params;
4228 struct rte_cryptodev_sym_session *sess;
4229 struct rte_crypto_op *ops[pparams->burst_size];
4230 struct rte_crypto_op *proc_ops[pparams->burst_size];
4231 uint32_t total_operations = pparams->total_operations;
4233 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4234 uint64_t processed = 0, failed_polls = 0, retries = 0;
4235 uint64_t tsc_start = 0, tsc_end = 0;
4237 uint16_t i = 0, l = 0, m = 0;
4238 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4239 uint16_t ops_unused = 0;
4241 struct rte_mbuf *mbufs[burst];
4242 struct crypto_params m_hlp[burst];
4244 if (rte_cryptodev_count() == 0) {
4245 printf("\nNo crypto devices available. "
4246 "Is kernel driver loaded?\n");
4250 sess = test_perf_create_session(dev_id, pparams);
4251 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4253 for (i = 0; i < burst; i++) {
4254 mbufs[i] = test_perf_create_pktmbuf_fill(
4256 pparams, pparams->symmetric_op->p_len,
4261 total_operations = test_ops;
4263 tsc_start = rte_rdtsc_precise();
4264 while (total_enqueued < total_operations) {
4265 uint16_t burst_size =
4266 total_enqueued+pparams->burst_size <= total_operations ?
4267 pparams->burst_size : total_operations-total_enqueued;
4268 uint16_t ops_needed = burst_size-ops_unused;
4270 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4271 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4272 printf("\nFailed to alloc enough ops, "
4273 "finish dequeuing");
4275 for (i = 0; i < ops_needed; i++)
4276 ops[i] = perf_gcm_set_crypto_op(ops[i],
4277 mbufs[i + (pparams->burst_size *
4278 (j % NUM_MBUF_SETS))],
4279 sess, &m_hlp[i + (pparams->burst_size *
4280 (j % NUM_MBUF_SETS))], pparams);
4283 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4284 queue_id, ops, burst_size);
4286 if (burst_enqueued < burst_size)
4289 ops_unused = burst_size-burst_enqueued;
4290 total_enqueued += burst_enqueued;
4294 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4295 proc_ops, pparams->burst_size);
4296 if (burst_dequeued == 0)
4299 processed += burst_dequeued;
4301 for (l = 0; l < burst_dequeued; l++)
4302 rte_crypto_op_free(proc_ops[l]);
4308 /* Dequeue any operations still in the crypto device */
4309 while (processed < total_operations) {
4310 /* Sending 0 length burst to flush sw crypto device */
4311 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4314 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4315 proc_ops, pparams->burst_size);
4316 if (burst_dequeued == 0)
4319 processed += burst_dequeued;
4321 for (m = 0; m < burst_dequeued; m++) {
4323 uint8_t *pkt = rte_pktmbuf_mtod(
4324 proc_ops[m]->sym->m_src,
4327 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4328 pparams->symmetric_op->c_data,
4330 pparams->session_attrs->aad_len,
4331 pparams->symmetric_op->c_len,
4332 "GCM Ciphertext data not as expected");
4334 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4335 pparams->symmetric_op->t_data,
4337 pparams->session_attrs->aad_len +
4338 pparams->symmetric_op->c_len,
4339 pparams->symmetric_op->t_len,
4340 "GCM MAC data not as expected");
4343 rte_crypto_op_free(proc_ops[m]);
4348 tsc_end = rte_rdtsc_precise();
4350 double ops_s = ((double)processed / (tsc_end - tsc_start))
4352 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4356 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4357 pparams->symmetric_op->p_len,
4358 ops_s/1000000, throughput, retries, failed_polls);
4361 for (i = 0; i < burst; i++)
4362 rte_pktmbuf_free(mbufs[i]);
4363 rte_cryptodev_sym_session_free(dev_id, sess);
4369 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4371 uint16_t i, j, k, loops = 1;
4373 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4375 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4376 &AES_GCM_128_12IV_0AAD
4379 if (continual_buf_len)
4380 loops = continual_size;
4382 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4384 const unsigned burst_size = 32;
4386 struct symmetric_op ops_set[TEST_CASES_GCM];
4387 struct perf_test_params params_set[TEST_CASES_GCM];
4388 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4389 static const struct cryptodev_perf_test_data *gcm_test;
4391 for (i = 0; i < TEST_CASES_GCM; ++i) {
4393 gcm_test = gcm_tests[i];
4395 session_attrs[i].cipher =
4396 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4397 session_attrs[i].cipher_algorithm =
4398 RTE_CRYPTO_CIPHER_AES_GCM;
4399 session_attrs[i].key_cipher_data =
4401 session_attrs[i].key_cipher_len =
4403 session_attrs[i].auth_algorithm =
4404 RTE_CRYPTO_AUTH_AES_GCM;
4405 session_attrs[i].auth =
4406 RTE_CRYPTO_AUTH_OP_GENERATE;
4407 session_attrs[i].key_auth_data = NULL;
4408 session_attrs[i].key_auth_len = 0;
4409 session_attrs[i].aad_len = gcm_test->aad.len;
4410 session_attrs[i].digest_len =
4411 gcm_test->auth_tag.len;
4412 session_attrs[i].iv_len = gcm_test->iv.len;
4413 session_attrs[i].iv_data = gcm_test->iv.data;
4415 ops_set[i].aad_data = gcm_test->aad.data;
4416 ops_set[i].p_data = gcm_test->plaintext.data;
4417 ops_set[i].p_len = buf_lengths[i];
4418 ops_set[i].c_data = gcm_test->ciphertext.data;
4419 ops_set[i].c_len = buf_lengths[i];
4420 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4421 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4423 params_set[i].chain = CIPHER_HASH;
4424 params_set[i].session_attrs = &session_attrs[i];
4425 params_set[i].symmetric_op = &ops_set[i];
4426 if (continual_buf_len)
4427 params_set[i].total_operations = 0xFFFFFF;
4429 params_set[i].total_operations = 1000000;
4431 params_set[i].burst_size = burst_size;
4435 if (continual_buf_len)
4436 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4437 " burst size: %u", "AES_GCM", "AES_GCM",
4438 gcm_test->key.len << 3, burst_size);
4440 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4442 if (!continual_buf_len) {
4443 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4444 " burst size: %u", "AES_GCM", "AES_GCM",
4445 gcm_test->key.len << 3, burst_size);
4446 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4447 " Retries\tEmptyPolls");
4450 uint16_t len = RTE_DIM(buf_lengths);
4453 if (continual_buf_len) {
4454 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4455 if (buf_lengths[k] == continual_buf_len) {
4461 for (j = p; j < len; ++j) {
4463 params_set[i].symmetric_op->c_len = buf_lengths[j];
4464 params_set[i].symmetric_op->p_len = buf_lengths[j];
4466 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4467 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4469 /* Run is twice, one for encryption/hash checks,
4472 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4476 for (k = 0; k < loops; k++) {
4477 if (continual_buf_len)
4478 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4479 "Throughput(Gbps)\t"
4480 "Retries\tEmptyPolls");
4481 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4484 if (continual_buf_len)
4485 printf("\n\nCompleted loop %i of %i ...",
4495 static int test_cryptodev_perf_AES_GCM(void)
4497 return test_perf_AES_GCM(0, 0);
4500 * This function calls AES GCM performance tests providing
4501 * size of packet as an argument. If size of packet is not
4502 * in the buf_lengths array, all sizes will be used
4504 static int test_continual_perf_AES_GCM(void)
4506 return test_perf_AES_GCM(1024, 10);
4510 test_perf_continual_performance_test(void)
4512 unsigned int total_operations = 0xFFFFFF;
4513 unsigned int total_loops = 10;
4514 unsigned int burst_size = 32;
4517 struct perf_test_params params_set = {
4518 .total_operations = total_operations,
4519 .burst_size = burst_size,
4522 .chain = CIPHER_HASH,
4524 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4525 .cipher_key_length = 16,
4526 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4529 for (i = 1; i <= total_loops; ++i) {
4530 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4531 " burst_size: %d ops\n",
4532 chain_mode_name(params_set.chain),
4533 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4534 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4535 params_set.cipher_key_length,
4537 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4538 "Retries\tEmptyPolls\n");
4539 test_perf_aes_sha(testsuite_params.dev_id, 0,
4541 printf("\nCompleted loop %i of %i ...", i, total_loops);
4546 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4547 .suite_name = "Crypto Device Continual Performance Test",
4548 .setup = testsuite_setup,
4549 .teardown = testsuite_teardown,
4550 .unit_test_cases = {
4551 TEST_CASE_ST(ut_setup, ut_teardown,
4552 test_perf_continual_performance_test),
4553 TEST_CASE_ST(ut_setup, ut_teardown,
4554 test_continual_perf_AES_GCM),
4555 TEST_CASES_END() /**< NULL terminate unit test array */
4559 static struct unit_test_suite cryptodev_testsuite = {
4560 .suite_name = "Crypto Device Unit Test Suite",
4561 .setup = testsuite_setup,
4562 .teardown = testsuite_teardown,
4563 .unit_test_cases = {
4564 TEST_CASE_ST(ut_setup, ut_teardown,
4565 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4566 TEST_CASE_ST(ut_setup, ut_teardown,
4567 test_cryptodev_perf_AES_GCM),
4568 TEST_CASE_ST(ut_setup, ut_teardown,
4569 test_perf_aes_cbc_vary_burst_size),
4570 TEST_CASES_END() /**< NULL terminate unit test array */
4574 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4575 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4576 .setup = testsuite_setup,
4577 .teardown = testsuite_teardown,
4578 .unit_test_cases = {
4579 TEST_CASE_ST(ut_setup, ut_teardown,
4580 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4581 TEST_CASES_END() /**< NULL terminate unit test array */
4585 static struct unit_test_suite cryptodev_gcm_testsuite = {
4586 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4587 .setup = testsuite_setup,
4588 .teardown = testsuite_teardown,
4589 .unit_test_cases = {
4590 TEST_CASE_ST(ut_setup, ut_teardown,
4591 test_cryptodev_perf_AES_GCM),
4592 TEST_CASES_END() /**< NULL terminate unit test array */
4596 static struct unit_test_suite cryptodev_aes_testsuite = {
4597 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4598 .setup = testsuite_setup,
4599 .teardown = testsuite_teardown,
4600 .unit_test_cases = {
4601 TEST_CASE_ST(ut_setup, ut_teardown,
4602 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4603 TEST_CASES_END() /**< NULL terminate unit test array */
4607 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4608 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4609 .setup = testsuite_setup,
4610 .teardown = testsuite_teardown,
4611 .unit_test_cases = {
4612 TEST_CASE_ST(ut_setup, ut_teardown,
4613 test_perf_snow3G_vary_pkt_size),
4614 TEST_CASE_ST(ut_setup, ut_teardown,
4615 test_perf_snow3G_vary_burst_size),
4616 TEST_CASES_END() /**< NULL terminate unit test array */
4620 static struct unit_test_suite cryptodev_openssl_testsuite = {
4621 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4622 .setup = testsuite_setup,
4623 .teardown = testsuite_teardown,
4624 .unit_test_cases = {
4625 TEST_CASE_ST(ut_setup, ut_teardown,
4626 test_perf_openssl_vary_pkt_size),
4627 TEST_CASE_ST(ut_setup, ut_teardown,
4628 test_perf_openssl_vary_burst_size),
4629 TEST_CASES_END() /**< NULL terminate unit test array */
4633 static struct unit_test_suite cryptodev_armv8_testsuite = {
4634 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4635 .setup = testsuite_setup,
4636 .teardown = testsuite_teardown,
4637 .unit_test_cases = {
4638 TEST_CASE_ST(ut_setup, ut_teardown,
4639 test_perf_armv8_vary_pkt_size),
4640 TEST_CASE_ST(ut_setup, ut_teardown,
4641 test_perf_armv8_vary_burst_size),
4642 TEST_CASES_END() /**< NULL terminate unit test array */
4647 perftest_aesni_gcm_cryptodev(void)
4649 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4651 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4655 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4657 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4659 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4663 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4665 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4667 return unit_test_suite_runner(&cryptodev_testsuite);
4671 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4673 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4675 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4679 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4681 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4683 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4687 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4689 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4691 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4695 perftest_qat_continual_cryptodev(void)
4697 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4699 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4703 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4705 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4707 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4711 perftest_dpaa2_sec_cryptodev(void)
4713 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4715 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4718 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4719 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4720 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4721 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4722 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4723 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4724 perftest_openssl_cryptodev);
4725 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4726 perftest_qat_continual_cryptodev);
4727 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4728 perftest_sw_armv8_cryptodev);
4729 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4730 perftest_dpaa2_sec_cryptodev);