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
49 #define PERF_NUM_OPS_INFLIGHT (128)
50 #define DEFAULT_NUM_REQS_TO_SUBMIT (10000000)
52 struct crypto_testsuite_params {
53 struct rte_mempool *mbuf_mp;
54 struct rte_mempool *op_mpool;
56 uint16_t nb_queue_pairs;
58 struct rte_cryptodev_config conf;
59 struct rte_cryptodev_qp_conf qp_conf;
72 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;
103 #define ALIGN_POW2_ROUNDUP(num, align) \
104 (((num) + (align) - 1) & ~((align) - 1))
107 * This struct is needed to avoid unnecessary allocation or checking
108 * of allocation of crypto params with current alloc on the fly
112 struct crypto_params {
117 struct perf_test_params {
119 unsigned total_operations;
123 enum chain_mode chain;
125 enum rte_crypto_cipher_algorithm cipher_algo;
126 unsigned cipher_key_length;
127 enum rte_crypto_auth_algorithm auth_algo;
129 struct symmetric_session_attrs *session_attrs;
131 struct symmetric_op *symmetric_op;
134 #define MAX_NUM_OF_OPS_PER_UT (128)
136 struct crypto_unittest_params {
137 struct rte_crypto_sym_xform cipher_xform;
138 struct rte_crypto_sym_xform auth_xform;
140 struct rte_cryptodev_sym_session *sess;
142 struct rte_crypto_op *op;
144 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
145 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
150 static struct rte_cryptodev_sym_session *
151 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
152 enum rte_crypto_cipher_algorithm cipher_algo,
153 unsigned int cipher_key_len,
154 enum rte_crypto_auth_algorithm auth_algo);
155 static struct rte_cryptodev_sym_session *
156 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
157 enum rte_crypto_cipher_algorithm cipher_algo,
158 unsigned int cipher_key_len,
159 enum rte_crypto_auth_algorithm auth_algo);
160 static struct rte_cryptodev_sym_session *
161 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
162 enum rte_crypto_cipher_algorithm cipher_algo,
163 unsigned int cipher_key_len,
164 enum rte_crypto_auth_algorithm auth_algo);
166 static struct rte_mbuf *
167 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
168 static inline struct rte_crypto_op *
169 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
170 struct rte_cryptodev_sym_session *sess, unsigned data_len,
171 unsigned digest_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 unsigned int digest_len, 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 unsigned int digest_len, 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 unsigned int digest_len, 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);
1981 op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1983 op->sym->auth.data.offset = 0;
1984 op->sym->auth.data.length = data_params[0].length;
1986 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
1987 aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
1989 op->sym->cipher.data.offset = 0;
1990 op->sym->cipher.data.length = data_params[0].length;
1997 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
1998 "algorithm with a constant request size of %u.",
1999 data_params[0].length);
2000 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2001 "cost for each request.");
2002 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2003 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2004 "(assuming 0 retries)");
2005 for (i = 2; i <= 128 ; i *= 2) {
2012 while (num_sent < num_to_submit) {
2013 start_cycles = rte_rdtsc_precise();
2014 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2015 0, &c_ops[num_sent],
2016 ((num_to_submit-num_sent) < burst_size) ?
2017 num_to_submit-num_sent : burst_size);
2018 if (burst_sent == 0)
2021 num_sent += burst_sent;
2022 end_cycles = rte_rdtsc_precise();
2023 total_cycles += (end_cycles - start_cycles);
2025 * Wait until requests have been sent.
2029 start_cycles = rte_rdtsc_precise();
2030 burst_received = rte_cryptodev_dequeue_burst(
2031 dev_num, 0, proc_ops, burst_size);
2032 if (burst_received == 0)
2035 num_received += burst_received;
2036 end_cycles = rte_rdtsc_precise();
2037 total_cycles += end_cycles - start_cycles;
2040 while (num_received != num_to_submit) {
2041 if (gbl_cryptodev_perftest_devtype ==
2042 RTE_CRYPTODEV_AESNI_MB_PMD)
2043 rte_cryptodev_enqueue_burst(dev_num, 0,
2046 burst_received = rte_cryptodev_dequeue_burst(
2047 dev_num, 0, proc_ops, burst_size);
2048 if (burst_received == 0)
2051 num_received += burst_received;
2054 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2055 num_sent, num_received, burst_size);
2056 printf("\t\t%"PRIu64, retries);
2057 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2061 for (i = 0; i < num_to_submit ; i++) {
2062 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2063 rte_crypto_op_free(c_ops[i]);
2065 return TEST_SUCCESS;
2069 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2071 uint32_t num_to_submit = pparams->total_operations;
2072 struct rte_crypto_op *c_ops[num_to_submit];
2073 struct rte_crypto_op *proc_ops[num_to_submit];
2074 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2075 uint32_t burst_sent = 0, burst_received = 0;
2076 uint32_t i, burst_size, num_sent, num_ops_received;
2077 struct crypto_testsuite_params *ts_params = &testsuite_params;
2078 static struct rte_cryptodev_sym_session *sess;
2080 if (rte_cryptodev_count() == 0) {
2081 printf("\nNo crypto devices found. Is PMD build configured?\n");
2082 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2086 /* Create Crypto session*/
2087 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2088 pparams->chain, pparams->cipher_algo,
2089 pparams->cipher_key_length, pparams->auth_algo);
2090 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2092 /* Generate Crypto op data structure(s)*/
2093 for (i = 0; i < num_to_submit ; i++) {
2094 struct rte_mbuf *m = test_perf_create_pktmbuf(
2097 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2099 struct rte_crypto_op *op =
2100 rte_crypto_op_alloc(ts_params->op_mpool,
2101 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2102 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2104 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size,
2105 get_auth_digest_length(pparams->auth_algo));
2106 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2111 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2112 "Packet Size %u bytes",
2113 pmd_name(gbl_cryptodev_perftest_devtype),
2114 ts_params->dev_id, 0,
2115 chain_mode_name(pparams->chain),
2116 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2117 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2119 printf("\nOps Tx\tOps Rx\tOps/burst ");
2120 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2122 for (i = 2; i <= 128 ; i *= 2) {
2124 num_ops_received = 0;
2129 while (num_sent < num_to_submit) {
2130 start_cycles = rte_rdtsc_precise();
2131 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2132 0, &c_ops[num_sent],
2133 ((num_to_submit-num_sent) < burst_size) ?
2134 num_to_submit-num_sent : burst_size);
2135 end_cycles = rte_rdtsc_precise();
2136 if (burst_sent == 0)
2138 num_sent += burst_sent;
2139 total_cycles += (end_cycles - start_cycles);
2141 /* Wait until requests have been sent. */
2145 start_cycles = rte_rdtsc_precise();
2146 burst_received = rte_cryptodev_dequeue_burst(
2147 ts_params->dev_id, 0, proc_ops, burst_size);
2148 end_cycles = rte_rdtsc_precise();
2149 if (burst_received < burst_sent)
2151 num_ops_received += burst_received;
2153 total_cycles += end_cycles - start_cycles;
2156 while (num_ops_received != num_to_submit) {
2157 if (gbl_cryptodev_perftest_devtype ==
2158 RTE_CRYPTODEV_AESNI_MB_PMD)
2159 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2161 start_cycles = rte_rdtsc_precise();
2162 burst_received = rte_cryptodev_dequeue_burst(
2163 ts_params->dev_id, 0, proc_ops, burst_size);
2164 end_cycles = rte_rdtsc_precise();
2165 total_cycles += end_cycles - start_cycles;
2166 if (burst_received == 0)
2168 num_ops_received += burst_received;
2171 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2172 printf("\t\t%"PRIu64, retries);
2173 printf("\t%"PRIu64, failed_polls);
2174 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2175 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2176 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2180 for (i = 0; i < num_to_submit ; i++) {
2181 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2182 rte_crypto_op_free(c_ops[i]);
2184 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2186 return TEST_SUCCESS;
2190 test_perf_snow3G_vary_burst_size(void)
2192 unsigned total_operations = 4096;
2193 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2194 uint16_t buf_lengths[] = {40};
2197 struct perf_test_params params_set[] = {
2199 .chain = CIPHER_ONLY,
2200 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2201 .cipher_key_length = 16,
2202 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2206 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2207 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2208 .cipher_key_length = 16
2212 printf("\n\nStart %s.", __func__);
2213 printf("\nThis Test measures the average IA cycle cost using a "
2214 "constant request(packet) size. ");
2215 printf("Cycle cost is only valid when indicators show device is not busy,"
2216 " i.e. Retries and EmptyPolls = 0");
2218 for (i = 0; i < RTE_DIM(params_set); i++) {
2220 params_set[i].total_operations = total_operations;
2223 j < RTE_DIM(buf_lengths);
2226 params_set[i].buf_size = buf_lengths[j];
2228 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2237 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2239 uint32_t num_to_submit = pparams->total_operations;
2240 struct rte_crypto_op *c_ops[num_to_submit];
2241 struct rte_crypto_op *proc_ops[num_to_submit];
2242 uint64_t failed_polls, retries, start_cycles,
2243 end_cycles, total_cycles = 0;
2244 uint32_t burst_sent = 0, burst_received = 0;
2245 uint32_t i, burst_size, num_sent, num_ops_received;
2247 struct crypto_testsuite_params *ts_params = &testsuite_params;
2249 static struct rte_cryptodev_sym_session *sess;
2251 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2252 (struct rte_crypto_op *, struct rte_mbuf *,
2253 struct rte_cryptodev_sym_session *,
2254 unsigned int, unsigned int,
2257 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2259 if (rte_cryptodev_count() == 0) {
2260 printf("\nNo crypto devices found. Is PMD build configured?\n");
2264 /* Create Crypto session*/
2265 sess = test_perf_create_openssl_session(ts_params->dev_id,
2266 pparams->chain, pparams->cipher_algo,
2267 pparams->cipher_key_length, pparams->auth_algo);
2268 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2270 /* Generate Crypto op data structure(s)*/
2271 for (i = 0; i < num_to_submit ; i++) {
2272 struct rte_mbuf *m = test_perf_create_pktmbuf(
2275 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2277 struct rte_crypto_op *op =
2278 rte_crypto_op_alloc(ts_params->op_mpool,
2279 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2280 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2282 switch (pparams->cipher_algo) {
2283 case RTE_CRYPTO_CIPHER_3DES_CBC:
2284 case RTE_CRYPTO_CIPHER_3DES_CTR:
2285 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2287 case RTE_CRYPTO_CIPHER_AES_CBC:
2288 case RTE_CRYPTO_CIPHER_AES_CTR:
2289 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2291 case RTE_CRYPTO_CIPHER_AES_GCM:
2292 test_perf_set_crypto_op =
2293 test_perf_set_crypto_op_aes_gcm;
2299 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2300 digest_length, pparams->chain);
2301 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2306 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2307 "auth_algo:%s, Packet Size %u bytes",
2308 pmd_name(gbl_cryptodev_perftest_devtype),
2309 ts_params->dev_id, 0,
2310 chain_mode_name(pparams->chain),
2311 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2312 pparams->cipher_key_length,
2313 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2315 printf("\nOps Tx\tOps Rx\tOps/burst ");
2316 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2319 for (i = 2; i <= 128 ; i *= 2) {
2321 num_ops_received = 0;
2326 while (num_sent < num_to_submit) {
2327 start_cycles = rte_rdtsc_precise();
2328 burst_sent = rte_cryptodev_enqueue_burst(
2330 0, &c_ops[num_sent],
2331 ((num_to_submit - num_sent) <
2333 num_to_submit - num_sent : burst_size);
2334 end_cycles = rte_rdtsc_precise();
2335 if (burst_sent == 0)
2337 num_sent += burst_sent;
2338 total_cycles += (end_cycles - start_cycles);
2340 /* Wait until requests have been sent. */
2343 start_cycles = rte_rdtsc_precise();
2344 burst_received = rte_cryptodev_dequeue_burst(
2345 ts_params->dev_id, 0, proc_ops,
2347 end_cycles = rte_rdtsc_precise();
2348 if (burst_received < burst_sent)
2350 num_ops_received += burst_received;
2352 total_cycles += end_cycles - start_cycles;
2355 while (num_ops_received != num_to_submit) {
2356 /* Sending 0 length burst to flush sw crypto device */
2357 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2360 start_cycles = rte_rdtsc_precise();
2361 burst_received = rte_cryptodev_dequeue_burst(
2362 ts_params->dev_id, 0, proc_ops,
2364 end_cycles = rte_rdtsc_precise();
2366 total_cycles += end_cycles - start_cycles;
2367 if (burst_received == 0)
2369 num_ops_received += burst_received;
2372 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2373 printf("\t\t%"PRIu64, retries);
2374 printf("\t%"PRIu64, failed_polls);
2375 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2376 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2378 printf("\t\t%"PRIu64,
2380 (num_ops_received * pparams->buf_size));
2384 for (i = 0; i < num_to_submit ; i++) {
2385 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2386 rte_crypto_op_free(c_ops[i]);
2388 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2390 return TEST_SUCCESS;
2394 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2396 uint32_t num_to_submit = pparams->total_operations;
2397 struct rte_crypto_op *c_ops[num_to_submit];
2398 struct rte_crypto_op *proc_ops[num_to_submit];
2399 uint64_t failed_polls, retries, start_cycles, end_cycles,
2401 uint32_t burst_sent = 0, burst_received = 0;
2402 uint32_t i, burst_size, num_sent, num_ops_received;
2405 struct crypto_testsuite_params *ts_params = &testsuite_params;
2407 static struct rte_cryptodev_sym_session *sess;
2409 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2411 if (rte_cryptodev_count() == 0) {
2412 printf("\nNo crypto devices found. Is PMD build configured?\n");
2416 /* Create Crypto session*/
2417 sess = test_perf_create_armv8_session(ts_params->dev_id,
2418 pparams->chain, pparams->cipher_algo,
2419 pparams->cipher_key_length, pparams->auth_algo);
2420 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2422 /* Generate Crypto op data structure(s)*/
2423 for (i = 0; i < num_to_submit ; i++) {
2424 struct rte_mbuf *m = test_perf_create_pktmbuf(
2427 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2429 struct rte_crypto_op *op =
2430 rte_crypto_op_alloc(ts_params->op_mpool,
2431 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2432 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2434 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2435 digest_length, pparams->chain);
2436 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2441 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2442 "auth_algo:%s, Packet Size %u bytes",
2443 pmd_name(gbl_cryptodev_perftest_devtype),
2444 ts_params->dev_id, 0,
2445 chain_mode_name(pparams->chain),
2446 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2447 pparams->cipher_key_length,
2448 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2450 printf("\nOps Tx\tOps Rx\tOps/burst ");
2452 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2454 for (i = 2; i <= 128 ; i *= 2) {
2456 num_ops_received = 0;
2461 while (num_sent < num_to_submit) {
2462 if ((num_to_submit - num_sent) < burst_size)
2463 nb_ops = num_to_submit - num_sent;
2465 nb_ops = burst_size;
2467 start_cycles = rte_rdtsc();
2468 burst_sent = rte_cryptodev_enqueue_burst(
2470 0, &c_ops[num_sent],
2472 end_cycles = rte_rdtsc();
2474 if (burst_sent == 0)
2476 num_sent += burst_sent;
2477 total_cycles += (end_cycles - start_cycles);
2479 start_cycles = rte_rdtsc();
2480 burst_received = rte_cryptodev_dequeue_burst(
2481 ts_params->dev_id, 0, proc_ops,
2483 end_cycles = rte_rdtsc();
2484 if (burst_received < burst_sent)
2486 num_ops_received += burst_received;
2488 total_cycles += end_cycles - start_cycles;
2491 while (num_ops_received != num_to_submit) {
2492 /* Sending 0 length burst to flush sw crypto device */
2493 rte_cryptodev_enqueue_burst(
2494 ts_params->dev_id, 0, NULL, 0);
2496 start_cycles = rte_rdtsc();
2497 burst_received = rte_cryptodev_dequeue_burst(
2498 ts_params->dev_id, 0, proc_ops, burst_size);
2499 end_cycles = rte_rdtsc();
2501 total_cycles += end_cycles - start_cycles;
2502 if (burst_received == 0)
2504 num_ops_received += burst_received;
2507 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2508 printf("\t\t%"PRIu64, retries);
2509 printf("\t%"PRIu64, failed_polls);
2510 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2511 printf("\t\t%"PRIu64,
2512 (total_cycles/num_ops_received)*burst_size);
2513 printf("\t\t%"PRIu64,
2514 total_cycles/(num_ops_received*pparams->buf_size));
2518 for (i = 0; i < num_to_submit ; i++) {
2519 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2520 rte_crypto_op_free(c_ops[i]);
2523 return TEST_SUCCESS;
2526 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2529 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2531 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2533 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2535 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2537 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2539 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2541 case RTE_CRYPTO_AUTH_AES_GCM:
2548 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2551 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2553 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2554 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2555 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2556 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2557 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2558 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2559 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2560 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2561 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2562 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2563 case RTE_CRYPTO_AUTH_AES_GCM:
2564 return DIGEST_BYTE_LENGTH_AES_GCM;
2570 static uint8_t aes_key[] = {
2571 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2572 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2573 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2574 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2577 static uint8_t aes_iv[] = {
2578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2579 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2582 static uint8_t aes_gcm_aad[] = {
2583 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2584 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2587 static uint8_t triple_des_key[] = {
2588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2589 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2590 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2593 static uint8_t triple_des_iv[] = {
2594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2597 static uint8_t hmac_sha_key[] = {
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,
2608 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2609 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2610 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2611 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2612 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2613 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2616 static uint8_t snow3g_cipher_key[] = {
2617 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2618 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2621 static uint8_t snow3g_iv[] = {
2622 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2623 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2626 static uint8_t snow3g_hash_key[] = {
2627 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2628 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2631 static struct rte_cryptodev_sym_session *
2632 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2633 enum rte_crypto_cipher_algorithm cipher_algo,
2634 unsigned cipher_key_len,
2635 enum rte_crypto_auth_algorithm auth_algo)
2637 struct rte_crypto_sym_xform cipher_xform = { 0 };
2638 struct rte_crypto_sym_xform auth_xform = { 0 };
2641 /* Setup Cipher Parameters */
2642 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2643 cipher_xform.cipher.algo = cipher_algo;
2644 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2646 cipher_xform.cipher.key.data = aes_key;
2647 cipher_xform.cipher.key.length = cipher_key_len;
2648 cipher_xform.cipher.iv.offset = IV_OFFSET;
2649 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2650 if (chain != CIPHER_ONLY) {
2651 /* Setup HMAC Parameters */
2652 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2653 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2654 auth_xform.auth.algo = auth_algo;
2655 auth_xform.auth.key.data = hmac_sha_key;
2656 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2657 auth_xform.auth.digest_length =
2658 get_auth_digest_length(auth_algo);
2662 cipher_xform.next = &auth_xform;
2663 auth_xform.next = NULL;
2664 /* Create Crypto session*/
2665 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2667 auth_xform.next = &cipher_xform;
2668 cipher_xform.next = NULL;
2669 /* Create Crypto session*/
2670 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2672 cipher_xform.next = NULL;
2673 /* Create Crypto session*/
2674 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2680 #define SNOW3G_CIPHER_IV_LENGTH 16
2682 static struct rte_cryptodev_sym_session *
2683 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2684 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2685 enum rte_crypto_auth_algorithm auth_algo)
2687 struct rte_crypto_sym_xform cipher_xform = {0};
2688 struct rte_crypto_sym_xform auth_xform = {0};
2691 /* Setup Cipher Parameters */
2692 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2693 cipher_xform.cipher.algo = cipher_algo;
2694 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2696 cipher_xform.cipher.key.data = snow3g_cipher_key;
2697 cipher_xform.cipher.key.length = cipher_key_len;
2698 cipher_xform.cipher.iv.offset = IV_OFFSET;
2699 cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2702 /* Setup HMAC Parameters */
2703 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2704 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2705 auth_xform.auth.algo = auth_algo;
2707 auth_xform.auth.key.data = snow3g_hash_key;
2708 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2709 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2710 /* Auth IV will be after cipher IV */
2711 auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
2712 auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2716 cipher_xform.next = &auth_xform;
2717 auth_xform.next = NULL;
2718 /* Create Crypto session*/
2719 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2721 auth_xform.next = &cipher_xform;
2722 cipher_xform.next = NULL;
2723 /* Create Crypto session*/
2724 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2726 cipher_xform.next = NULL;
2727 /* Create Crypto session*/
2728 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2730 auth_xform.next = NULL;
2731 /* Create Crypto session */
2732 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2738 static struct rte_cryptodev_sym_session *
2739 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2740 enum rte_crypto_cipher_algorithm cipher_algo,
2741 unsigned int cipher_key_len,
2742 enum rte_crypto_auth_algorithm auth_algo)
2744 struct rte_crypto_sym_xform cipher_xform = { 0 };
2745 struct rte_crypto_sym_xform auth_xform = { 0 };
2747 /* Setup Cipher Parameters */
2748 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2749 cipher_xform.cipher.algo = cipher_algo;
2750 cipher_xform.cipher.iv.offset = IV_OFFSET;
2751 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2753 switch (cipher_algo) {
2754 case RTE_CRYPTO_CIPHER_3DES_CBC:
2755 case RTE_CRYPTO_CIPHER_3DES_CTR:
2756 cipher_xform.cipher.key.data = triple_des_key;
2757 cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2759 case RTE_CRYPTO_CIPHER_AES_CBC:
2760 case RTE_CRYPTO_CIPHER_AES_CTR:
2761 case RTE_CRYPTO_CIPHER_AES_GCM:
2762 cipher_xform.cipher.key.data = aes_key;
2763 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2769 cipher_xform.cipher.key.length = cipher_key_len;
2771 /* Setup Auth Parameters */
2772 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2773 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2774 auth_xform.auth.algo = auth_algo;
2776 switch (auth_algo) {
2777 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2778 auth_xform.auth.key.data = hmac_sha_key;
2780 case RTE_CRYPTO_AUTH_AES_GCM:
2781 auth_xform.auth.key.data = NULL;
2787 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2788 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2792 cipher_xform.next = &auth_xform;
2793 auth_xform.next = NULL;
2794 /* Create Crypto session*/
2795 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2797 auth_xform.next = &cipher_xform;
2798 cipher_xform.next = NULL;
2799 /* Create Crypto session*/
2800 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2806 static struct rte_cryptodev_sym_session *
2807 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2808 enum rte_crypto_cipher_algorithm cipher_algo,
2809 unsigned int cipher_key_len,
2810 enum rte_crypto_auth_algorithm auth_algo)
2812 struct rte_crypto_sym_xform cipher_xform = { 0 };
2813 struct rte_crypto_sym_xform auth_xform = { 0 };
2815 /* Setup Cipher Parameters */
2816 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2817 cipher_xform.cipher.algo = cipher_algo;
2819 switch (cipher_algo) {
2820 case RTE_CRYPTO_CIPHER_AES_CBC:
2821 cipher_xform.cipher.key.data = aes_cbc_128_key;
2827 cipher_xform.cipher.key.length = cipher_key_len;
2828 cipher_xform.cipher.iv.offset = IV_OFFSET;
2829 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2831 /* Setup Auth Parameters */
2832 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2833 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2834 auth_xform.auth.algo = auth_algo;
2836 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2840 cipher_xform.next = &auth_xform;
2841 auth_xform.next = NULL;
2842 /* Encrypt and hash the result */
2843 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2844 /* Create Crypto session*/
2845 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2847 auth_xform.next = &cipher_xform;
2848 cipher_xform.next = NULL;
2849 /* Hash encrypted message and decrypt */
2850 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2851 /* Create Crypto session*/
2852 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2858 #define AES_GCM_AAD_LENGTH 16
2860 static struct rte_mbuf *
2861 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2863 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2865 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2866 rte_pktmbuf_free(m);
2870 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2875 static inline struct rte_crypto_op *
2876 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2877 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2878 unsigned int digest_len, enum chain_mode chain)
2880 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2881 rte_crypto_op_free(op);
2885 /* Authentication Parameters */
2886 if (chain == CIPHER_ONLY) {
2887 op->sym->auth.digest.data = NULL;
2888 op->sym->auth.digest.phys_addr = 0;
2889 op->sym->auth.digest.length = 0;
2890 op->sym->auth.aad.data = NULL;
2891 op->sym->auth.aad.length = 0;
2892 op->sym->auth.data.offset = 0;
2893 op->sym->auth.data.length = 0;
2895 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2896 uint8_t *, data_len);
2897 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2899 op->sym->auth.digest.length = digest_len;
2900 op->sym->auth.data.offset = 0;
2901 op->sym->auth.data.length = data_len;
2905 /* Copy the IV at the end of the crypto operation */
2906 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2907 aes_iv, AES_CIPHER_IV_LENGTH);
2909 /* Cipher Parameters */
2910 op->sym->cipher.data.offset = 0;
2911 op->sym->cipher.data.length = data_len;
2918 static inline struct rte_crypto_op *
2919 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2920 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2921 unsigned int digest_len, enum chain_mode chain __rte_unused)
2923 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2924 rte_crypto_op_free(op);
2928 /* Authentication Parameters */
2929 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2930 (m->data_off + data_len);
2931 op->sym->auth.digest.phys_addr =
2932 rte_pktmbuf_mtophys_offset(m, data_len);
2933 op->sym->auth.digest.length = digest_len;
2934 op->sym->auth.aad.data = aes_gcm_aad;
2935 op->sym->auth.aad.length = AES_GCM_AAD_LENGTH;
2937 /* Copy IV at the end of the crypto operation */
2938 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2939 aes_iv, AES_CIPHER_IV_LENGTH);
2941 /* Data lengths/offsets Parameters */
2942 op->sym->auth.data.offset = 0;
2943 op->sym->auth.data.length = data_len;
2945 op->sym->cipher.data.offset = 0;
2946 op->sym->cipher.data.length = data_len;
2953 static inline struct rte_crypto_op *
2954 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2955 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2956 unsigned digest_len)
2958 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
2959 uint8_t *, IV_OFFSET);
2961 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2962 rte_crypto_op_free(op);
2966 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2968 /* Authentication Parameters */
2969 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2970 (m->data_off + data_len);
2971 op->sym->auth.digest.phys_addr =
2972 rte_pktmbuf_mtophys_offset(m, data_len);
2973 op->sym->auth.digest.length = digest_len;
2975 /* Data lengths/offsets Parameters */
2976 op->sym->auth.data.offset = 0;
2977 op->sym->auth.data.length = data_len << 3;
2979 op->sym->cipher.data.offset = 0;
2980 op->sym->cipher.data.length = data_len << 3;
2987 static inline struct rte_crypto_op *
2988 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2990 struct rte_cryptodev_sym_session *sess,
2993 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2994 rte_crypto_op_free(op);
2998 /* Copy IV at the end of the crypto operation */
2999 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3000 snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3002 op->sym->cipher.data.offset = 0;
3003 op->sym->cipher.data.length = data_len << 3;
3011 static inline struct rte_crypto_op *
3012 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3014 struct rte_cryptodev_sym_session *sess,
3016 unsigned digest_len)
3018 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3019 uint8_t *, IV_OFFSET);
3021 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3022 rte_crypto_op_free(op);
3026 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3028 /* Authentication Parameters */
3030 op->sym->auth.digest.data =
3031 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3033 op->sym->auth.digest.phys_addr =
3034 rte_pktmbuf_mtophys_offset(m, data_len +
3035 SNOW3G_CIPHER_IV_LENGTH);
3036 op->sym->auth.digest.length = digest_len;
3038 /* Data lengths/offsets Parameters */
3039 op->sym->auth.data.offset = 0;
3040 op->sym->auth.data.length = data_len << 3;
3048 static inline struct rte_crypto_op *
3049 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3050 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3051 unsigned int digest_len, enum chain_mode chain __rte_unused)
3053 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3054 rte_crypto_op_free(op);
3058 /* Authentication Parameters */
3059 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3060 (m->data_off + data_len);
3061 op->sym->auth.digest.phys_addr =
3062 rte_pktmbuf_mtophys_offset(m, data_len);
3063 op->sym->auth.digest.length = digest_len;
3065 /* Copy IV at the end of the crypto operation */
3066 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3067 triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3069 /* Data lengths/offsets Parameters */
3070 op->sym->auth.data.offset = 0;
3071 op->sym->auth.data.length = data_len;
3073 op->sym->cipher.data.offset = 0;
3074 op->sym->cipher.data.length = data_len;
3081 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3082 * same time, i.e. as they're not dereferenced there's no need to wait until
3083 * finished with to re-use */
3084 #define NUM_MBUF_SETS 8
3087 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3088 struct perf_test_params *pparams)
3090 uint16_t i, k, l, m;
3092 uint16_t ops_unused = 0;
3094 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3095 uint64_t processed = 0, failed_polls = 0, retries = 0;
3096 uint64_t tsc_start = 0, tsc_end = 0;
3098 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3100 struct rte_crypto_op *ops[pparams->burst_size];
3101 struct rte_crypto_op *proc_ops[pparams->burst_size];
3103 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3105 struct crypto_testsuite_params *ts_params = &testsuite_params;
3107 static struct rte_cryptodev_sym_session *sess;
3109 if (rte_cryptodev_count() == 0) {
3110 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3114 /* Create Crypto session*/
3115 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3116 pparams->chain, pparams->cipher_algo,
3117 pparams->cipher_key_length, pparams->auth_algo);
3118 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3120 /* Generate a burst of crypto operations */
3121 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3122 mbufs[i] = test_perf_create_pktmbuf(
3126 if (mbufs[i] == NULL) {
3127 printf("\nFailed to get mbuf - freeing the rest.\n");
3128 for (k = 0; k < i; k++)
3129 rte_pktmbuf_free(mbufs[k]);
3133 /* Make room for Digest in mbuf */
3134 if (pparams->chain != CIPHER_ONLY)
3135 rte_pktmbuf_append(mbufs[i], digest_length);
3139 tsc_start = rte_rdtsc_precise();
3141 while (total_enqueued < pparams->total_operations) {
3142 uint16_t burst_size =
3143 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3144 pparams->burst_size : pparams->total_operations-total_enqueued;
3145 uint16_t ops_needed = burst_size-ops_unused;
3147 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3148 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3149 printf("\nFailed to alloc enough ops, finish dequeuing "
3150 "and free ops below.");
3152 for (i = 0; i < ops_needed; i++)
3153 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3154 mbufs[i + (pparams->burst_size *
3155 (j % NUM_MBUF_SETS))],
3156 sess, pparams->buf_size, digest_length,
3160 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3161 queue_id, ops, burst_size);
3163 if (burst_enqueued < burst_size)
3166 ops_unused = burst_size-burst_enqueued;
3167 total_enqueued += burst_enqueued;
3171 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3172 proc_ops, pparams->burst_size);
3173 if (burst_dequeued == 0)
3176 processed += burst_dequeued;
3178 for (l = 0; l < burst_dequeued; l++)
3179 rte_crypto_op_free(proc_ops[l]);
3184 /* Dequeue any operations still in the crypto device */
3185 while (processed < pparams->total_operations) {
3186 /* Sending 0 length burst to flush sw crypto device */
3187 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3190 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3191 proc_ops, pparams->burst_size);
3192 if (burst_dequeued == 0)
3195 processed += burst_dequeued;
3197 for (m = 0; m < burst_dequeued; m++)
3198 rte_crypto_op_free(proc_ops[m]);
3202 tsc_end = rte_rdtsc_precise();
3204 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3205 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3207 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3208 throughput, retries, failed_polls);
3210 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3211 rte_pktmbuf_free(mbufs[i]);
3212 rte_cryptodev_sym_session_free(dev_id, sess);
3215 return TEST_SUCCESS;
3220 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3221 struct perf_test_params *pparams)
3223 uint16_t i, k, l, m;
3225 uint16_t ops_unused = 0;
3226 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3227 uint64_t processed = 0, failed_polls = 0, retries = 0;
3228 uint64_t tsc_start = 0, tsc_end = 0;
3230 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3232 struct rte_crypto_op *ops[pparams->burst_size];
3233 struct rte_crypto_op *proc_ops[pparams->burst_size];
3235 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3237 struct crypto_testsuite_params *ts_params = &testsuite_params;
3239 static struct rte_cryptodev_sym_session *sess;
3241 if (rte_cryptodev_count() == 0) {
3242 printf("\nNo crypto devices found. Is PMD build configured?\n");
3243 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3247 /* Create Crypto session*/
3248 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3249 pparams->chain, pparams->cipher_algo,
3250 pparams->cipher_key_length, pparams->auth_algo);
3251 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3253 /* Generate a burst of crypto operations */
3254 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3256 * Buffer size is allocated, for perf tests they
3257 * are equal + digest len.
3259 mbufs[i] = test_perf_create_pktmbuf(
3264 if (mbufs[i] == NULL) {
3265 printf("\nFailed to get mbuf - freeing the rest.\n");
3266 for (k = 0; k < i; k++)
3267 rte_pktmbuf_free(mbufs[k]);
3273 tsc_start = rte_rdtsc_precise();
3275 while (total_enqueued < pparams->total_operations) {
3276 uint16_t burst_size =
3277 (total_enqueued+pparams->burst_size)
3278 <= pparams->total_operations ?
3279 pparams->burst_size : pparams->total_operations-total_enqueued;
3280 uint16_t ops_needed = burst_size-ops_unused;
3281 /* Handle the last burst correctly */
3282 uint16_t op_offset = pparams->burst_size - burst_size;
3285 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3286 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3287 ops+op_offset, ops_needed)) {
3288 printf("\nFailed to alloc enough ops.");
3289 /*Don't exit, dequeue, more ops should become available*/
3291 for (i = 0; i < ops_needed; i++) {
3292 if (pparams->chain == HASH_ONLY)
3294 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3296 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3298 pparams->buf_size, digest_length);
3299 else if (pparams->chain == CIPHER_ONLY)
3301 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3303 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3312 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3313 ops+op_offset, burst_size);
3315 if (burst_enqueued < burst_size)
3318 ops_unused = burst_size-burst_enqueued;
3319 total_enqueued += burst_enqueued;
3323 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3324 proc_ops, pparams->burst_size);
3325 if (burst_dequeued == 0) {
3328 processed += burst_dequeued;
3329 for (l = 0; l < burst_dequeued; l++)
3330 rte_crypto_op_free(proc_ops[l]);
3335 /* Dequeue any operations still in the crypto device */
3336 while (processed < pparams->total_operations) {
3337 /* Sending 0 length burst to flush sw crypto device */
3338 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3341 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3342 proc_ops, pparams->burst_size);
3343 if (burst_dequeued == 0)
3346 processed += burst_dequeued;
3347 for (m = 0; m < burst_dequeued; m++)
3348 rte_crypto_op_free(proc_ops[m]);
3352 tsc_end = rte_rdtsc_precise();
3354 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3355 double cycles_burst = (double) (tsc_end - tsc_start) /
3356 (double) processed * pparams->burst_size;
3357 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3358 double cycles_B = cycles_buff / pparams->buf_size;
3359 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3361 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3362 /* Cycle count misleading on HW devices for this test, so don't print */
3363 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3364 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3365 pparams->buf_size, ops_s/1000000,
3366 throughput, retries, failed_polls);
3368 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3369 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3370 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3371 cycles_buff, cycles_B, retries, failed_polls);
3374 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3375 rte_pktmbuf_free(mbufs[i]);
3376 rte_cryptodev_sym_session_free(dev_id, sess);
3379 return TEST_SUCCESS;
3383 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3384 struct perf_test_params *pparams)
3386 uint16_t i, k, l, m;
3388 uint16_t ops_unused = 0;
3390 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3391 uint64_t processed = 0, failed_polls = 0, retries = 0;
3392 uint64_t tsc_start = 0, tsc_end = 0;
3394 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3396 struct rte_crypto_op *ops[pparams->burst_size];
3397 struct rte_crypto_op *proc_ops[pparams->burst_size];
3399 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3401 struct crypto_testsuite_params *ts_params = &testsuite_params;
3403 static struct rte_cryptodev_sym_session *sess;
3405 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3406 (struct rte_crypto_op *, struct rte_mbuf *,
3407 struct rte_cryptodev_sym_session *,
3408 unsigned int, unsigned int,
3411 switch (pparams->cipher_algo) {
3412 case RTE_CRYPTO_CIPHER_3DES_CBC:
3413 case RTE_CRYPTO_CIPHER_3DES_CTR:
3414 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3416 case RTE_CRYPTO_CIPHER_AES_CBC:
3417 case RTE_CRYPTO_CIPHER_AES_CTR:
3418 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3420 case RTE_CRYPTO_CIPHER_AES_GCM:
3421 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3427 if (rte_cryptodev_count() == 0) {
3428 printf("\nNo crypto devices found. Is PMD build configured?\n");
3432 /* Create Crypto session*/
3433 sess = test_perf_create_openssl_session(ts_params->dev_id,
3434 pparams->chain, pparams->cipher_algo,
3435 pparams->cipher_key_length, pparams->auth_algo);
3436 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3438 /* Generate a burst of crypto operations */
3439 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3440 mbufs[i] = test_perf_create_pktmbuf(
3444 if (mbufs[i] == NULL) {
3445 printf("\nFailed to get mbuf - freeing the rest.\n");
3446 for (k = 0; k < i; k++)
3447 rte_pktmbuf_free(mbufs[k]);
3452 tsc_start = rte_rdtsc_precise();
3454 while (total_enqueued < pparams->total_operations) {
3455 uint16_t burst_size =
3456 total_enqueued + pparams->burst_size <=
3457 pparams->total_operations ? pparams->burst_size :
3458 pparams->total_operations - total_enqueued;
3459 uint16_t ops_needed = burst_size - ops_unused;
3461 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3462 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3463 printf("\nFailed to alloc enough ops, finish dequeuing "
3464 "and free ops below.");
3466 for (i = 0; i < ops_needed; i++)
3467 ops[i] = test_perf_set_crypto_op(ops[i],
3468 mbufs[i + (pparams->burst_size *
3469 (j % NUM_MBUF_SETS))],
3470 sess, pparams->buf_size, digest_length,
3474 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3475 queue_id, ops, burst_size);
3477 if (burst_enqueued < burst_size)
3480 ops_unused = burst_size - burst_enqueued;
3481 total_enqueued += burst_enqueued;
3485 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3486 proc_ops, pparams->burst_size);
3487 if (burst_dequeued == 0)
3490 processed += burst_dequeued;
3492 for (l = 0; l < burst_dequeued; l++)
3493 rte_crypto_op_free(proc_ops[l]);
3498 /* Dequeue any operations still in the crypto device */
3499 while (processed < pparams->total_operations) {
3500 /* Sending 0 length burst to flush sw crypto device */
3501 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3504 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3505 proc_ops, pparams->burst_size);
3506 if (burst_dequeued == 0)
3509 processed += burst_dequeued;
3511 for (m = 0; m < burst_dequeued; m++)
3512 rte_crypto_op_free(proc_ops[m]);
3516 tsc_end = rte_rdtsc_precise();
3518 double ops_s = ((double)processed / (tsc_end - tsc_start))
3520 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3523 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3524 ops_s / 1000000, throughput, retries, failed_polls);
3526 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3527 rte_pktmbuf_free(mbufs[i]);
3528 rte_cryptodev_sym_session_free(dev_id, sess);
3531 return TEST_SUCCESS;
3535 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3536 struct perf_test_params *pparams)
3538 uint16_t i, k, l, m;
3540 uint16_t ops_unused = 0;
3541 uint16_t burst_size;
3542 uint16_t ops_needed;
3544 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3545 uint64_t processed = 0, failed_polls = 0, retries = 0;
3546 uint64_t tsc_start = 0, tsc_end = 0;
3548 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3550 struct rte_crypto_op *ops[pparams->burst_size];
3551 struct rte_crypto_op *proc_ops[pparams->burst_size];
3553 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3555 struct crypto_testsuite_params *ts_params = &testsuite_params;
3557 static struct rte_cryptodev_sym_session *sess;
3559 if (rte_cryptodev_count() == 0) {
3560 printf("\nNo crypto devices found. Is PMD build configured?\n");
3564 /* Create Crypto session*/
3565 sess = test_perf_create_armv8_session(ts_params->dev_id,
3566 pparams->chain, pparams->cipher_algo,
3567 pparams->cipher_key_length, pparams->auth_algo);
3568 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3570 /* Generate a burst of crypto operations */
3571 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3572 mbufs[i] = test_perf_create_pktmbuf(
3576 if (mbufs[i] == NULL) {
3577 printf("\nFailed to get mbuf - freeing the rest.\n");
3578 for (k = 0; k < i; k++)
3579 rte_pktmbuf_free(mbufs[k]);
3584 tsc_start = rte_rdtsc();
3586 while (total_enqueued < pparams->total_operations) {
3587 if ((total_enqueued + pparams->burst_size) <=
3588 pparams->total_operations)
3589 burst_size = pparams->burst_size;
3591 burst_size = pparams->total_operations - total_enqueued;
3593 ops_needed = burst_size - ops_unused;
3595 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3596 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3597 printf("\nFailed to alloc enough ops, finish dequeuing "
3598 "and free ops below.");
3600 for (i = 0; i < ops_needed; i++)
3601 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3602 mbufs[i + (pparams->burst_size *
3603 (j % NUM_MBUF_SETS))], sess,
3604 pparams->buf_size, digest_length,
3608 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3609 queue_id, ops, burst_size);
3611 if (burst_enqueued < burst_size)
3614 ops_unused = burst_size - burst_enqueued;
3615 total_enqueued += burst_enqueued;
3619 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3620 proc_ops, pparams->burst_size);
3621 if (burst_dequeued == 0)
3624 processed += burst_dequeued;
3626 for (l = 0; l < burst_dequeued; l++)
3627 rte_crypto_op_free(proc_ops[l]);
3632 /* Dequeue any operations still in the crypto device */
3633 while (processed < pparams->total_operations) {
3634 /* Sending 0 length burst to flush sw crypto device */
3635 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3638 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3639 proc_ops, pparams->burst_size);
3640 if (burst_dequeued == 0)
3643 processed += burst_dequeued;
3645 for (m = 0; m < burst_dequeued; m++)
3646 rte_crypto_op_free(proc_ops[m]);
3650 tsc_end = rte_rdtsc();
3652 double ops_s = ((double)processed / (tsc_end - tsc_start))
3654 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3657 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3658 ops_s / 1000000, throughput, retries, failed_polls);
3660 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3661 rte_pktmbuf_free(mbufs[i]);
3664 return TEST_SUCCESS;
3669 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3670 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3671 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3673 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3674 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3675 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3677 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3678 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3679 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3682 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3684 unsigned total_operations = 1000000;
3685 unsigned burst_size = 32;
3686 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3689 struct perf_test_params params_set[] = {
3691 .chain = CIPHER_ONLY,
3692 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3693 .cipher_key_length = 16,
3694 .auth_algo = RTE_CRYPTO_AUTH_NULL
3697 .chain = CIPHER_HASH,
3698 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3699 .cipher_key_length = 16,
3700 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3703 .chain = CIPHER_HASH,
3705 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3706 .cipher_key_length = 16,
3707 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3710 .chain = CIPHER_HASH,
3712 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3713 .cipher_key_length = 16,
3714 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3717 .chain = CIPHER_HASH,
3719 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3720 .cipher_key_length = 32,
3721 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3724 .chain = CIPHER_HASH,
3726 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3727 .cipher_key_length = 32,
3728 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3731 .chain = CIPHER_HASH,
3733 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3734 .cipher_key_length = 32,
3735 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3739 for (i = 0; i < RTE_DIM(params_set); i++) {
3741 params_set[i].total_operations = total_operations;
3742 params_set[i].burst_size = burst_size;
3743 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3744 " burst_size: %d ops\n",
3745 chain_mode_name(params_set[i].chain),
3746 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3747 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3748 params_set[i].cipher_key_length,
3750 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3751 "Retries\tEmptyPolls\n");
3752 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3753 params_set[i].buf_size = buf_lengths[j];
3754 test_perf_aes_sha(testsuite_params.dev_id, 0,
3762 test_perf_snow3G_vary_pkt_size(void)
3764 unsigned total_operations = 1000000;
3767 uint16_t burst_sizes[] = { 64 };
3768 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3770 struct perf_test_params params_set[] = {
3772 .chain = CIPHER_ONLY,
3773 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3774 .cipher_key_length = 16,
3775 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3779 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3780 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3781 .cipher_key_length = 16
3785 printf("\n\nStart %s.", __func__);
3786 printf("\nTest to measure max throughput at various pkt sizes.");
3787 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3788 " so cycle cost not relevant (n/a displayed).");
3790 for (i = 0; i < RTE_DIM(params_set); i++) {
3792 params_set[i].total_operations = total_operations;
3793 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3794 enum rte_crypto_cipher_algorithm cipher_algo =
3795 params_set[i].cipher_algo;
3796 enum rte_crypto_auth_algorithm auth_algo =
3797 params_set[i].auth_algo;
3798 printf("\nOn %s dev%u qp%u, %s, "
3799 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3800 pmd_name(gbl_cryptodev_perftest_devtype),
3801 testsuite_params.dev_id, 0,
3802 chain_mode_name(params_set[i].chain),
3803 rte_crypto_cipher_algorithm_strings[cipher_algo],
3804 rte_crypto_auth_algorithm_strings[auth_algo],
3807 params_set[i].burst_size = burst_sizes[k];
3808 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3809 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3810 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3812 params_set[i].buf_size = buf_lengths[j];
3814 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3823 test_perf_openssl_vary_pkt_size(void)
3825 unsigned int total_operations = 10000;
3826 unsigned int burst_size = { 64 };
3827 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3831 struct perf_test_params params_set[] = {
3833 .chain = CIPHER_HASH,
3835 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3836 .cipher_key_length = 16,
3837 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3840 .chain = CIPHER_HASH,
3842 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3843 .cipher_key_length = 24,
3844 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3847 .chain = CIPHER_HASH,
3849 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3850 .cipher_key_length = 16,
3851 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3854 .chain = CIPHER_HASH,
3856 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3857 .cipher_key_length = 32,
3858 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3861 .chain = CIPHER_HASH,
3863 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3864 .cipher_key_length = 16,
3865 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3868 .chain = CIPHER_HASH,
3870 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3871 .cipher_key_length = 24,
3872 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3875 .chain = CIPHER_HASH,
3877 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3878 .cipher_key_length = 16,
3879 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3883 for (i = 0; i < RTE_DIM(params_set); i++) {
3884 params_set[i].total_operations = total_operations;
3885 params_set[i].burst_size = burst_size;
3886 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3887 " burst_size: %d ops\n",
3888 chain_mode_name(params_set[i].chain),
3889 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3890 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3891 params_set[i].cipher_key_length,
3893 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3895 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3896 params_set[i].buf_size = buf_lengths[j];
3897 test_perf_openssl(testsuite_params.dev_id, 0,
3906 test_perf_openssl_vary_burst_size(void)
3908 unsigned int total_operations = 4096;
3909 uint16_t buf_lengths[] = { 40 };
3912 struct perf_test_params params_set[] = {
3914 .chain = CIPHER_HASH,
3916 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3917 .cipher_key_length = 16,
3918 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3921 .chain = CIPHER_HASH,
3923 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3924 .cipher_key_length = 24,
3925 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3928 .chain = CIPHER_HASH,
3930 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3931 .cipher_key_length = 16,
3932 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3935 .chain = CIPHER_HASH,
3937 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3938 .cipher_key_length = 32,
3939 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3942 .chain = CIPHER_HASH,
3944 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3945 .cipher_key_length = 16,
3946 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3949 .chain = CIPHER_HASH,
3951 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3952 .cipher_key_length = 24,
3953 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3956 .chain = CIPHER_HASH,
3958 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3959 .cipher_key_length = 16,
3960 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3964 printf("\n\nStart %s.", __func__);
3965 printf("\nThis Test measures the average IA cycle cost using a "
3966 "constant request(packet) size. ");
3967 printf("Cycle cost is only valid when indicators show device is not"
3968 " busy, i.e. Retries and EmptyPolls = 0");
3970 for (i = 0; i < RTE_DIM(params_set); i++) {
3972 params_set[i].total_operations = total_operations;
3974 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3975 params_set[i].buf_size = buf_lengths[j];
3976 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3984 test_perf_armv8_vary_pkt_size(void)
3986 unsigned int total_operations = 100000;
3987 unsigned int burst_size = { 64 };
3988 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3992 struct perf_test_params params_set[] = {
3994 .chain = CIPHER_HASH,
3996 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3997 .cipher_key_length = 16,
3998 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4001 .chain = HASH_CIPHER,
4003 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4004 .cipher_key_length = 16,
4005 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4008 .chain = CIPHER_HASH,
4010 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4011 .cipher_key_length = 16,
4012 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4015 .chain = HASH_CIPHER,
4017 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4018 .cipher_key_length = 16,
4019 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4023 for (i = 0; i < RTE_DIM(params_set); i++) {
4024 params_set[i].total_operations = total_operations;
4025 params_set[i].burst_size = burst_size;
4026 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4027 " burst_size: %d ops\n",
4028 chain_mode_name(params_set[i].chain),
4029 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4030 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4031 params_set[i].cipher_key_length,
4033 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4035 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4036 params_set[i].buf_size = buf_lengths[j];
4037 test_perf_armv8(testsuite_params.dev_id, 0,
4046 test_perf_armv8_vary_burst_size(void)
4048 unsigned int total_operations = 4096;
4049 uint16_t buf_lengths[] = { 64 };
4052 struct perf_test_params params_set[] = {
4054 .chain = CIPHER_HASH,
4056 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4057 .cipher_key_length = 16,
4058 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4061 .chain = HASH_CIPHER,
4063 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4064 .cipher_key_length = 16,
4065 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4068 .chain = CIPHER_HASH,
4070 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4071 .cipher_key_length = 16,
4072 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4075 .chain = HASH_CIPHER,
4077 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4078 .cipher_key_length = 16,
4079 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4083 printf("\n\nStart %s.", __func__);
4084 printf("\nThis Test measures the average IA cycle cost using a "
4085 "constant request(packet) size. ");
4086 printf("Cycle cost is only valid when indicators show device is "
4087 "not busy, i.e. Retries and EmptyPolls = 0");
4089 for (i = 0; i < RTE_DIM(params_set); i++) {
4091 params_set[i].total_operations = total_operations;
4093 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4094 params_set[i].buf_size = buf_lengths[j];
4095 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4103 test_perf_aes_cbc_vary_burst_size(void)
4105 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4109 static struct rte_cryptodev_sym_session *
4110 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4112 static struct rte_cryptodev_sym_session *sess;
4113 struct rte_crypto_sym_xform cipher_xform = { 0 };
4114 struct rte_crypto_sym_xform auth_xform = { 0 };
4116 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4117 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4119 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4120 pparams->session_attrs->key_cipher_len);
4121 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4122 pparams->session_attrs->key_auth_len);
4124 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4125 cipher_xform.next = NULL;
4127 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4128 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4129 cipher_xform.cipher.key.data = cipher_key;
4130 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4131 cipher_xform.cipher.iv.length = pparams->session_attrs->iv_len;
4132 cipher_xform.cipher.iv.offset = IV_OFFSET;
4134 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4135 auth_xform.next = NULL;
4137 auth_xform.auth.op = pparams->session_attrs->auth;
4138 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4140 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4141 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4144 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4145 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4146 cipher_xform.next = &auth_xform;
4147 sess = rte_cryptodev_sym_session_create(dev_id,
4150 auth_xform.next = &cipher_xform;
4151 sess = rte_cryptodev_sym_session_create(dev_id,
4158 static inline struct rte_crypto_op *
4159 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4160 struct rte_cryptodev_sym_session *sess,
4161 struct crypto_params *m_hlp,
4162 struct perf_test_params *params)
4164 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4165 uint8_t *, IV_OFFSET);
4167 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4168 rte_crypto_op_free(op);
4172 op->sym->auth.digest.data = m_hlp->digest;
4173 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4175 params->symmetric_op->aad_len +
4176 params->symmetric_op->p_len);
4178 op->sym->auth.digest.length = params->symmetric_op->t_len;
4180 op->sym->auth.aad.data = m_hlp->aad;
4181 op->sym->auth.aad.length = params->symmetric_op->aad_len;
4182 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
4184 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4185 params->symmetric_op->aad_len);
4187 rte_memcpy(iv_ptr, params->session_attrs->iv_data,
4188 params->session_attrs->iv_len);
4189 if (params->session_attrs->iv_len == 12)
4192 op->sym->auth.data.offset =
4193 params->symmetric_op->aad_len;
4194 op->sym->auth.data.length = params->symmetric_op->p_len;
4196 op->sym->cipher.data.offset =
4197 params->symmetric_op->aad_len;
4198 op->sym->cipher.data.length = params->symmetric_op->p_len;
4205 static struct rte_mbuf *
4206 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4207 struct perf_test_params *params,
4208 unsigned buf_sz, struct crypto_params *m_hlp)
4210 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4211 uint16_t aad_len = params->symmetric_op->aad_len;
4212 uint16_t digest_size = params->symmetric_op->t_len;
4215 p = rte_pktmbuf_append(m, aad_len);
4217 rte_pktmbuf_free(m);
4220 m_hlp->aad = (uint8_t *)p;
4222 p = rte_pktmbuf_append(m, buf_sz);
4224 rte_pktmbuf_free(m);
4227 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4229 p = rte_pktmbuf_append(m, digest_size);
4231 rte_pktmbuf_free(m);
4234 m_hlp->digest = (uint8_t *)p;
4240 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4241 struct perf_test_params *pparams, uint32_t test_ops)
4244 struct crypto_testsuite_params *ts_params = &testsuite_params;
4245 struct rte_cryptodev_sym_session *sess;
4246 struct rte_crypto_op *ops[pparams->burst_size];
4247 struct rte_crypto_op *proc_ops[pparams->burst_size];
4248 uint32_t total_operations = pparams->total_operations;
4250 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4251 uint64_t processed = 0, failed_polls = 0, retries = 0;
4252 uint64_t tsc_start = 0, tsc_end = 0;
4254 uint16_t i = 0, l = 0, m = 0;
4255 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4256 uint16_t ops_unused = 0;
4258 struct rte_mbuf *mbufs[burst];
4259 struct crypto_params m_hlp[burst];
4261 if (rte_cryptodev_count() == 0) {
4262 printf("\nNo crypto devices available. "
4263 "Is kernel driver loaded?\n");
4267 sess = test_perf_create_session(dev_id, pparams);
4268 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4270 for (i = 0; i < burst; i++) {
4271 mbufs[i] = test_perf_create_pktmbuf_fill(
4273 pparams, pparams->symmetric_op->p_len,
4278 total_operations = test_ops;
4280 tsc_start = rte_rdtsc_precise();
4281 while (total_enqueued < total_operations) {
4282 uint16_t burst_size =
4283 total_enqueued+pparams->burst_size <= total_operations ?
4284 pparams->burst_size : total_operations-total_enqueued;
4285 uint16_t ops_needed = burst_size-ops_unused;
4287 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4288 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4289 printf("\nFailed to alloc enough ops, "
4290 "finish dequeuing");
4292 for (i = 0; i < ops_needed; i++)
4293 ops[i] = perf_gcm_set_crypto_op(ops[i],
4294 mbufs[i + (pparams->burst_size *
4295 (j % NUM_MBUF_SETS))],
4296 sess, &m_hlp[i + (pparams->burst_size *
4297 (j % NUM_MBUF_SETS))], pparams);
4300 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4301 queue_id, ops, burst_size);
4303 if (burst_enqueued < burst_size)
4306 ops_unused = burst_size-burst_enqueued;
4307 total_enqueued += burst_enqueued;
4311 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4312 proc_ops, pparams->burst_size);
4313 if (burst_dequeued == 0)
4316 processed += burst_dequeued;
4318 for (l = 0; l < burst_dequeued; l++)
4319 rte_crypto_op_free(proc_ops[l]);
4325 /* Dequeue any operations still in the crypto device */
4326 while (processed < total_operations) {
4327 /* Sending 0 length burst to flush sw crypto device */
4328 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4331 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4332 proc_ops, pparams->burst_size);
4333 if (burst_dequeued == 0)
4336 processed += burst_dequeued;
4338 for (m = 0; m < burst_dequeued; m++) {
4340 uint8_t *pkt = rte_pktmbuf_mtod(
4341 proc_ops[m]->sym->m_src,
4344 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4345 pparams->symmetric_op->c_data,
4347 pparams->symmetric_op->aad_len,
4348 pparams->symmetric_op->c_len,
4349 "GCM Ciphertext data not as expected");
4351 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4352 pparams->symmetric_op->t_data,
4354 pparams->symmetric_op->aad_len +
4355 pparams->symmetric_op->c_len,
4356 pparams->symmetric_op->t_len,
4357 "GCM MAC data not as expected");
4360 rte_crypto_op_free(proc_ops[m]);
4365 tsc_end = rte_rdtsc_precise();
4367 double ops_s = ((double)processed / (tsc_end - tsc_start))
4369 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4373 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4374 pparams->symmetric_op->p_len,
4375 ops_s/1000000, throughput, retries, failed_polls);
4378 for (i = 0; i < burst; i++)
4379 rte_pktmbuf_free(mbufs[i]);
4380 rte_cryptodev_sym_session_free(dev_id, sess);
4386 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4388 uint16_t i, j, k, loops = 1;
4390 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4392 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4393 &AES_GCM_128_12IV_0AAD
4396 if (continual_buf_len)
4397 loops = continual_size;
4399 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4401 const unsigned burst_size = 32;
4403 struct symmetric_op ops_set[TEST_CASES_GCM];
4404 struct perf_test_params params_set[TEST_CASES_GCM];
4405 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4406 static const struct cryptodev_perf_test_data *gcm_test;
4408 for (i = 0; i < TEST_CASES_GCM; ++i) {
4410 gcm_test = gcm_tests[i];
4412 session_attrs[i].cipher =
4413 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4414 session_attrs[i].cipher_algorithm =
4415 RTE_CRYPTO_CIPHER_AES_GCM;
4416 session_attrs[i].key_cipher_data =
4418 session_attrs[i].key_cipher_len =
4420 session_attrs[i].auth_algorithm =
4421 RTE_CRYPTO_AUTH_AES_GCM;
4422 session_attrs[i].auth =
4423 RTE_CRYPTO_AUTH_OP_GENERATE;
4424 session_attrs[i].key_auth_data = NULL;
4425 session_attrs[i].key_auth_len = 0;
4426 session_attrs[i].digest_len =
4427 gcm_test->auth_tag.len;
4428 session_attrs[i].iv_len = gcm_test->iv.len;
4429 session_attrs[i].iv_data = gcm_test->iv.data;
4431 ops_set[i].aad_data = gcm_test->aad.data;
4432 ops_set[i].aad_len = gcm_test->aad.len;
4433 ops_set[i].p_data = gcm_test->plaintext.data;
4434 ops_set[i].p_len = buf_lengths[i];
4435 ops_set[i].c_data = gcm_test->ciphertext.data;
4436 ops_set[i].c_len = buf_lengths[i];
4437 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4438 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4440 params_set[i].chain = CIPHER_HASH;
4441 params_set[i].session_attrs = &session_attrs[i];
4442 params_set[i].symmetric_op = &ops_set[i];
4443 if (continual_buf_len)
4444 params_set[i].total_operations = 0xFFFFFF;
4446 params_set[i].total_operations = 1000000;
4448 params_set[i].burst_size = burst_size;
4452 if (continual_buf_len)
4453 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4454 " burst size: %u", "AES_GCM", "AES_GCM",
4455 gcm_test->key.len << 3, burst_size);
4457 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4459 if (!continual_buf_len) {
4460 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4461 " burst size: %u", "AES_GCM", "AES_GCM",
4462 gcm_test->key.len << 3, burst_size);
4463 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4464 " Retries\tEmptyPolls");
4467 uint16_t len = RTE_DIM(buf_lengths);
4470 if (continual_buf_len) {
4471 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4472 if (buf_lengths[k] == continual_buf_len) {
4478 for (j = p; j < len; ++j) {
4480 params_set[i].symmetric_op->c_len = buf_lengths[j];
4481 params_set[i].symmetric_op->p_len = buf_lengths[j];
4483 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4484 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4486 /* Run is twice, one for encryption/hash checks,
4489 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4493 for (k = 0; k < loops; k++) {
4494 if (continual_buf_len)
4495 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4496 "Throughput(Gbps)\t"
4497 "Retries\tEmptyPolls");
4498 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4501 if (continual_buf_len)
4502 printf("\n\nCompleted loop %i of %i ...",
4512 static int test_cryptodev_perf_AES_GCM(void)
4514 return test_perf_AES_GCM(0, 0);
4517 * This function calls AES GCM performance tests providing
4518 * size of packet as an argument. If size of packet is not
4519 * in the buf_lengths array, all sizes will be used
4521 static int test_continual_perf_AES_GCM(void)
4523 return test_perf_AES_GCM(1024, 10);
4527 test_perf_continual_performance_test(void)
4529 unsigned int total_operations = 0xFFFFFF;
4530 unsigned int total_loops = 10;
4531 unsigned int burst_size = 32;
4534 struct perf_test_params params_set = {
4535 .total_operations = total_operations,
4536 .burst_size = burst_size,
4539 .chain = CIPHER_HASH,
4541 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4542 .cipher_key_length = 16,
4543 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4546 for (i = 1; i <= total_loops; ++i) {
4547 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4548 " burst_size: %d ops\n",
4549 chain_mode_name(params_set.chain),
4550 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4551 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4552 params_set.cipher_key_length,
4554 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4555 "Retries\tEmptyPolls\n");
4556 test_perf_aes_sha(testsuite_params.dev_id, 0,
4558 printf("\nCompleted loop %i of %i ...", i, total_loops);
4563 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4564 .suite_name = "Crypto Device Continual Performance Test",
4565 .setup = testsuite_setup,
4566 .teardown = testsuite_teardown,
4567 .unit_test_cases = {
4568 TEST_CASE_ST(ut_setup, ut_teardown,
4569 test_perf_continual_performance_test),
4570 TEST_CASE_ST(ut_setup, ut_teardown,
4571 test_continual_perf_AES_GCM),
4572 TEST_CASES_END() /**< NULL terminate unit test array */
4576 static struct unit_test_suite cryptodev_testsuite = {
4577 .suite_name = "Crypto Device Unit Test Suite",
4578 .setup = testsuite_setup,
4579 .teardown = testsuite_teardown,
4580 .unit_test_cases = {
4581 TEST_CASE_ST(ut_setup, ut_teardown,
4582 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4583 TEST_CASE_ST(ut_setup, ut_teardown,
4584 test_cryptodev_perf_AES_GCM),
4585 TEST_CASE_ST(ut_setup, ut_teardown,
4586 test_perf_aes_cbc_vary_burst_size),
4587 TEST_CASES_END() /**< NULL terminate unit test array */
4591 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4592 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4593 .setup = testsuite_setup,
4594 .teardown = testsuite_teardown,
4595 .unit_test_cases = {
4596 TEST_CASE_ST(ut_setup, ut_teardown,
4597 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4598 TEST_CASES_END() /**< NULL terminate unit test array */
4602 static struct unit_test_suite cryptodev_gcm_testsuite = {
4603 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4604 .setup = testsuite_setup,
4605 .teardown = testsuite_teardown,
4606 .unit_test_cases = {
4607 TEST_CASE_ST(ut_setup, ut_teardown,
4608 test_cryptodev_perf_AES_GCM),
4609 TEST_CASES_END() /**< NULL terminate unit test array */
4613 static struct unit_test_suite cryptodev_aes_testsuite = {
4614 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4615 .setup = testsuite_setup,
4616 .teardown = testsuite_teardown,
4617 .unit_test_cases = {
4618 TEST_CASE_ST(ut_setup, ut_teardown,
4619 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4620 TEST_CASES_END() /**< NULL terminate unit test array */
4624 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4625 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4626 .setup = testsuite_setup,
4627 .teardown = testsuite_teardown,
4628 .unit_test_cases = {
4629 TEST_CASE_ST(ut_setup, ut_teardown,
4630 test_perf_snow3G_vary_pkt_size),
4631 TEST_CASE_ST(ut_setup, ut_teardown,
4632 test_perf_snow3G_vary_burst_size),
4633 TEST_CASES_END() /**< NULL terminate unit test array */
4637 static struct unit_test_suite cryptodev_openssl_testsuite = {
4638 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4639 .setup = testsuite_setup,
4640 .teardown = testsuite_teardown,
4641 .unit_test_cases = {
4642 TEST_CASE_ST(ut_setup, ut_teardown,
4643 test_perf_openssl_vary_pkt_size),
4644 TEST_CASE_ST(ut_setup, ut_teardown,
4645 test_perf_openssl_vary_burst_size),
4646 TEST_CASES_END() /**< NULL terminate unit test array */
4650 static struct unit_test_suite cryptodev_armv8_testsuite = {
4651 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4652 .setup = testsuite_setup,
4653 .teardown = testsuite_teardown,
4654 .unit_test_cases = {
4655 TEST_CASE_ST(ut_setup, ut_teardown,
4656 test_perf_armv8_vary_pkt_size),
4657 TEST_CASE_ST(ut_setup, ut_teardown,
4658 test_perf_armv8_vary_burst_size),
4659 TEST_CASES_END() /**< NULL terminate unit test array */
4664 perftest_aesni_gcm_cryptodev(void)
4666 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4668 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4672 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4674 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4676 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4680 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4682 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4684 return unit_test_suite_runner(&cryptodev_testsuite);
4688 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4690 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4692 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4696 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4698 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4700 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4704 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4706 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4708 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4712 perftest_qat_continual_cryptodev(void)
4714 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4716 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4720 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4722 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4724 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4728 perftest_dpaa2_sec_cryptodev(void)
4730 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4732 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4735 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4736 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4737 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4738 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4739 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4740 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4741 perftest_openssl_cryptodev);
4742 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4743 perftest_qat_continual_cryptodev);
4744 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4745 perftest_sw_armv8_cryptodev);
4746 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4747 perftest_dpaa2_sec_cryptodev);