4 * Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * * Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * * Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in
14 * the documentation and/or other materials provided with the
16 * * Neither the name of Intel Corporation nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33 #include <rte_common.h>
35 #include <rte_malloc.h>
36 #include <rte_memcpy.h>
38 #include <rte_crypto.h>
39 #include <rte_cryptodev.h>
40 #include <rte_cycles.h>
43 #include "test_cryptodev.h"
44 #include "test_cryptodev_gcm_test_vectors.h"
46 #define AES_CIPHER_IV_LENGTH 16
47 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
48 #define AES_GCM_AAD_LENGTH 16
50 #define PERF_NUM_OPS_INFLIGHT (128)
51 #define DEFAULT_NUM_REQS_TO_SUBMIT (10000000)
53 struct crypto_testsuite_params {
54 struct rte_mempool *mbuf_mp;
55 struct rte_mempool *op_mpool;
57 uint16_t nb_queue_pairs;
59 struct rte_cryptodev_config conf;
60 struct rte_cryptodev_qp_conf qp_conf;
73 const uint8_t *aad_data;
75 const uint8_t *p_data;
78 const uint8_t *c_data;
81 const uint8_t *t_data;
86 struct symmetric_session_attrs {
87 enum rte_crypto_cipher_operation cipher;
88 enum rte_crypto_auth_operation auth;
90 enum rte_crypto_cipher_algorithm cipher_algorithm;
91 const uint8_t *key_cipher_data;
92 uint32_t key_cipher_len;
94 enum rte_crypto_auth_algorithm auth_algorithm;
95 const uint8_t *key_auth_data;
96 uint32_t key_auth_len;
98 const uint8_t *iv_data;
104 #define ALIGN_POW2_ROUNDUP(num, align) \
105 (((num) + (align) - 1) & ~((align) - 1))
108 * This struct is needed to avoid unnecessary allocation or checking
109 * of allocation of crypto params with current alloc on the fly
113 struct crypto_params {
118 struct perf_test_params {
120 unsigned total_operations;
124 enum chain_mode chain;
126 enum rte_crypto_cipher_algorithm cipher_algo;
127 unsigned cipher_key_length;
128 enum rte_crypto_auth_algorithm auth_algo;
130 struct symmetric_session_attrs *session_attrs;
132 struct symmetric_op *symmetric_op;
135 #define MAX_NUM_OF_OPS_PER_UT (128)
137 struct crypto_unittest_params {
138 struct rte_crypto_sym_xform cipher_xform;
139 struct rte_crypto_sym_xform auth_xform;
141 struct rte_cryptodev_sym_session *sess;
143 struct rte_crypto_op *op;
145 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
146 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
151 static struct rte_cryptodev_sym_session *
152 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
153 enum rte_crypto_cipher_algorithm cipher_algo,
154 unsigned int cipher_key_len,
155 enum rte_crypto_auth_algorithm auth_algo);
156 static struct rte_cryptodev_sym_session *
157 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
158 enum rte_crypto_cipher_algorithm cipher_algo,
159 unsigned int cipher_key_len,
160 enum rte_crypto_auth_algorithm auth_algo);
161 static struct rte_cryptodev_sym_session *
162 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
163 enum rte_crypto_cipher_algorithm cipher_algo,
164 unsigned int cipher_key_len,
165 enum rte_crypto_auth_algorithm auth_algo);
167 static struct rte_mbuf *
168 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
169 static inline struct rte_crypto_op *
170 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
171 struct rte_cryptodev_sym_session *sess, unsigned data_len,
172 unsigned digest_len);
173 static inline struct rte_crypto_op *
174 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
175 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
176 unsigned int digest_len, enum chain_mode chain);
177 static inline struct rte_crypto_op *
178 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
179 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
180 unsigned int digest_len, enum chain_mode chain __rte_unused);
181 static inline struct rte_crypto_op *
182 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
183 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
184 unsigned int digest_len, enum chain_mode chain __rte_unused);
185 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
188 static const char *chain_mode_name(enum chain_mode mode)
191 case CIPHER_HASH: return "cipher_hash"; break;
192 case HASH_CIPHER: return "hash_cipher"; break;
193 case CIPHER_ONLY: return "cipher_only"; break;
194 case HASH_ONLY: return "hash_only"; break;
195 default: return ""; break;
199 static const char *pmd_name(enum rte_cryptodev_type pmd)
202 case RTE_CRYPTODEV_NULL_PMD: return RTE_STR(CRYPTODEV_NAME_NULL_PMD); break;
203 case RTE_CRYPTODEV_AESNI_GCM_PMD:
204 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
205 case RTE_CRYPTODEV_AESNI_MB_PMD:
206 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
207 case RTE_CRYPTODEV_QAT_SYM_PMD:
208 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
209 case RTE_CRYPTODEV_SNOW3G_PMD:
210 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
211 case RTE_CRYPTODEV_DPAA2_SEC_PMD:
212 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
218 static struct rte_mbuf *
219 setup_test_string(struct rte_mempool *mpool,
220 const uint8_t *data, size_t len, uint8_t blocksize)
222 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
223 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
226 char *dst = rte_pktmbuf_append(m, t_len);
233 rte_memcpy(dst, (const void *)data, t_len);
238 static struct crypto_testsuite_params testsuite_params = { NULL };
239 static struct crypto_unittest_params unittest_params;
240 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
243 testsuite_setup(void)
245 struct crypto_testsuite_params *ts_params = &testsuite_params;
246 struct rte_cryptodev_info info;
247 unsigned i, nb_devs, valid_dev_id = 0;
251 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
252 if (ts_params->mbuf_mp == NULL) {
253 /* Not already created so create */
254 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
255 "CRYPTO_PERF_MBUFPOOL",
256 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
258 if (ts_params->mbuf_mp == NULL) {
259 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
265 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
266 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
267 NUM_MBUFS, MBUF_CACHE_SIZE,
269 sizeof(struct rte_crypto_sym_xform) +
272 if (ts_params->op_mpool == NULL) {
273 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
277 /* Create an AESNI MB device if required */
278 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_MB_PMD) {
279 #ifndef RTE_LIBRTE_PMD_AESNI_MB
280 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
281 " enabled in config file to run this testsuite.\n");
284 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD);
287 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
289 TEST_ASSERT(ret == 0,
290 "Failed to create instance of pmd : %s",
291 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
295 /* Create an AESNI GCM device if required */
296 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_GCM_PMD) {
297 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
298 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
299 " enabled in config file to run this testsuite.\n");
302 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD);
305 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
307 TEST_ASSERT(ret == 0,
308 "Failed to create instance of pmd : %s",
309 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
313 /* Create a SNOW3G device if required */
314 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_SNOW3G_PMD) {
315 #ifndef RTE_LIBRTE_PMD_SNOW3G
316 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
317 " enabled in config file to run this testsuite.\n");
320 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
323 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
325 TEST_ASSERT(ret == 0,
326 "Failed to create instance of pmd : %s",
327 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
331 /* Create an OPENSSL device if required */
332 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_OPENSSL_PMD) {
333 #ifndef RTE_LIBRTE_PMD_OPENSSL
334 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
335 " enabled in config file to run this testsuite.\n");
338 nb_devs = rte_cryptodev_count_devtype(
339 RTE_CRYPTODEV_OPENSSL_PMD);
342 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
345 TEST_ASSERT(ret == 0, "Failed to create "
346 "instance of pmd : %s",
347 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
351 /* Create an ARMv8 device if required */
352 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_ARMV8_PMD) {
353 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
354 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
355 " enabled in config file to run this testsuite.\n");
358 nb_devs = rte_cryptodev_count_devtype(
359 RTE_CRYPTODEV_ARMV8_PMD);
362 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
365 TEST_ASSERT(ret == 0, "Failed to create "
366 "instance of pmd : %s",
367 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
371 #ifndef RTE_LIBRTE_PMD_QAT
372 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
373 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
374 "in config file to run this testsuite.\n");
379 nb_devs = rte_cryptodev_count();
381 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
385 /* Search for the first valid */
386 for (i = 0; i < nb_devs; i++) {
387 rte_cryptodev_info_get(i, &info);
388 if (info.dev_type == gbl_cryptodev_perftest_devtype) {
389 ts_params->dev_id = i;
399 * Using Crypto Device Id 0 by default.
400 * Set up all the qps on this device
403 rte_cryptodev_info_get(ts_params->dev_id, &info);
405 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
406 ts_params->conf.socket_id = SOCKET_ID_ANY;
407 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
409 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
411 "Failed to configure cryptodev %u",
414 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
415 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
417 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
418 ts_params->dev_id, qp_id,
420 rte_cryptodev_socket_id(ts_params->dev_id)),
421 "Failed to setup queue pair %u on cryptodev %u",
422 qp_id, ts_params->dev_id);
428 testsuite_teardown(void)
430 struct crypto_testsuite_params *ts_params =
433 if (ts_params->mbuf_mp != NULL)
434 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
435 rte_mempool_avail_count(ts_params->mbuf_mp));
436 if (ts_params->op_mpool != NULL)
437 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
438 rte_mempool_avail_count(ts_params->op_mpool));
444 struct crypto_testsuite_params *ts_params = &testsuite_params;
445 struct crypto_unittest_params *ut_params = &unittest_params;
447 /* Clear unit test parameters before running test */
448 memset(ut_params, 0, sizeof(*ut_params));
450 rte_cryptodev_stats_reset(ts_params->dev_id);
452 /* Start the device */
453 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
454 "Failed to start cryptodev %u",
463 struct crypto_testsuite_params *ts_params = &testsuite_params;
464 struct crypto_unittest_params *ut_params = &unittest_params;
465 struct rte_cryptodev_stats stats;
469 /* free crypto session structure */
471 rte_cryptodev_sym_session_free(ts_params->dev_id,
474 /* free crypto operation structure */
476 rte_crypto_op_free(ut_params->op);
478 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
479 if (ut_params->obuf[i])
480 rte_pktmbuf_free(ut_params->obuf[i]);
481 else if (ut_params->ibuf[i])
482 rte_pktmbuf_free(ut_params->ibuf[i]);
485 if (ts_params->mbuf_mp != NULL)
486 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
487 rte_mempool_avail_count(ts_params->mbuf_mp));
489 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
491 /* Stop the device */
492 rte_cryptodev_stop(ts_params->dev_id);
495 const char plaintext_quote[] =
496 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
497 "Marseilles--The Arrival. On the 24th of February, 1815, the "
498 "look-out at Notre-Dame de la Garde signalled the three-master,"
499 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
500 "pilot put off immediately, and rounding the Chateau d'If, got "
501 "on board the vessel between Cape Morgion and Rion island. "
502 "Immediately, and according to custom, the ramparts of Fort "
503 "Saint-Jean were covered with spectators; it is always an event "
504 "at Marseilles for a ship to come into port, especially when "
505 "this ship, like the Pharaon, has been built, rigged, and laden"
506 " at the old Phocee docks, and belongs to an owner of the city."
507 " The ship drew on and had safely passed the strait, which some"
508 " volcanic shock has made between the Calasareigne and Jaros "
509 "islands; had doubled Pomegue, and approached the harbor under"
510 " topsails, jib, and spanker, but so slowly and sedately that"
511 " the idlers, with that instinct which is the forerunner of "
512 "evil, asked one another what misfortune could have happened "
513 "on board. However, those experienced in navigation saw plainly"
514 " that if any accident had occurred, it was not to the vessel "
515 "herself, for she bore down with all the evidence of being "
516 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
517 "already eased off, and standing by the side of the pilot, who"
518 " was steering the Pharaon towards the narrow entrance of the"
519 " inner port, was a young man, who, with activity and vigilant"
520 " eye, watched every motion of the ship, and repeated each "
521 "direction of the pilot. The vague disquietude which prevailed "
522 "among the spectators had so much affected one of the crowd "
523 "that he did not await the arrival of the vessel in harbor, but"
524 " jumping into a small skiff, desired to be pulled alongside "
525 "the Pharaon, which he reached as she rounded into La Reserve "
526 "basin. When the young man on board saw this person approach, "
527 "he left his station by the pilot, and, hat in hand, leaned "
528 "over the ship's bulwarks. He was a fine, tall, slim young "
529 "fellow of eighteen or twenty, with black eyes, and hair as "
530 "dark as a raven's wing; and his whole appearance bespoke that "
531 "calmness and resolution peculiar to men accustomed from their "
532 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
533 "cried the man in the skiff. \"What's the matter? and why have "
534 "you such an air of sadness aboard?\" \"A great misfortune, M. "
535 "Morrel,\" replied the young man,--\"a great misfortune, for me"
536 " especially! Off Civita Vecchia we lost our brave Captain "
537 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
538 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
539 " that head. But poor Captain Leclere--\" \"What happened to "
540 "him?\" asked the owner, with an air of considerable "
541 "resignation. \"What happened to the worthy captain?\" \"He "
542 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
543 "brain-fever in dreadful agony.\" Then turning to the crew, "
544 "he said, \"Bear a hand there, to take in sail!\" All hands "
545 "obeyed, and at once the eight or ten seamen who composed the "
546 "crew, sprang to their respective stations at the spanker "
547 "brails and outhaul, topsail sheets and halyards, the jib "
548 "downhaul, and the topsail clewlines and buntlines. The young "
549 "sailor gave a look to see that his orders were promptly and "
550 "accurately obeyed, and then turned again to the owner. \"And "
551 "how did this misfortune occur?\" inquired the latter, resuming"
552 " the interrupted conversation. \"Alas, sir, in the most "
553 "unexpected manner. After a long talk with the harbor-master, "
554 "Captain Leclere left Naples greatly disturbed in mind. In "
555 "twenty-four hours he was attacked by a fever, and died three "
556 "days afterwards. We performed the usual burial service, and he"
557 " is at his rest, sewn up in his hammock with a thirty-six "
558 "pound shot at his head and his heels, off El Giglio island. "
559 "We bring to his widow his sword and cross of honor. It was "
560 "worth while, truly,\" added the young man with a melancholy "
561 "smile, \"to make war against the English for ten years, and "
562 "to die in his bed at last, like everybody else.";
564 #define QUOTE_LEN_64B (64)
565 #define QUOTE_LEN_128B (128)
566 #define QUOTE_LEN_256B (256)
567 #define QUOTE_LEN_512B (512)
568 #define QUOTE_LEN_768B (768)
569 #define QUOTE_LEN_1024B (1024)
570 #define QUOTE_LEN_1280B (1280)
571 #define QUOTE_LEN_1536B (1536)
572 #define QUOTE_LEN_1792B (1792)
573 #define QUOTE_LEN_2048B (2048)
576 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
578 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
580 #define CIPHER_KEY_LENGTH_AES_CBC (16)
581 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
583 static uint8_t aes_cbc_128_key[] = {
584 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
585 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
587 static uint8_t aes_cbc_128_iv[] = {
588 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
589 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
591 static uint8_t hmac_sha256_key[] = {
592 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
593 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
594 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
595 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
598 /* Cipher text output */
600 static const uint8_t AES_CBC_ciphertext_64B[] = {
601 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
602 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
603 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
604 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
605 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
606 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
607 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
608 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
611 static const uint8_t AES_CBC_ciphertext_128B[] = {
612 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
613 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
614 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
615 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
616 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
617 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
618 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
619 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
620 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
621 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
622 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
623 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
624 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
625 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
626 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
627 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
630 static const uint8_t AES_CBC_ciphertext_256B[] = {
631 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
632 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
633 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
634 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
635 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
636 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
637 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
638 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
639 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
640 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
641 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
642 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
643 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
644 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
645 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
646 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
647 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
648 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
649 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
650 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
651 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
652 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
653 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
654 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
655 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
656 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
657 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
658 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
659 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
660 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
661 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
662 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
665 static const uint8_t AES_CBC_ciphertext_512B[] = {
666 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
667 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
668 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
669 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
670 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
671 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
672 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
673 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
674 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
675 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
676 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
677 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
678 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
679 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
680 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
681 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
682 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
683 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
684 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
685 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
686 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
687 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
688 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
689 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
690 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
691 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
692 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
693 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
694 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
695 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
696 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
697 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
698 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
699 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
700 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
701 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
702 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
703 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
704 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
705 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
706 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
707 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
708 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
709 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
710 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
711 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
712 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
713 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
714 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
715 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
716 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
717 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
718 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
719 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
720 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
721 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
722 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
723 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
724 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
725 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
726 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
727 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
728 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
729 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
732 static const uint8_t AES_CBC_ciphertext_768B[] = {
733 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
734 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
735 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
736 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
737 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
738 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
739 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
740 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
741 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
742 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
743 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
744 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
745 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
746 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
747 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
748 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
749 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
750 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
751 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
752 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
753 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
754 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
755 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
756 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
757 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
758 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
759 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
760 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
761 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
762 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
763 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
764 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
765 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
766 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
767 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
768 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
769 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
770 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
771 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
772 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
773 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
774 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
775 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
776 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
777 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
778 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
779 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
780 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
781 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
782 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
783 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
784 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
785 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
786 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
787 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
788 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
789 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
790 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
791 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
792 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
793 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
794 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
795 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
796 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
797 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
798 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
799 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
800 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
801 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
802 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
803 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
804 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
805 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
806 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
807 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
808 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
809 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
810 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
811 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
812 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
813 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
814 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
815 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
816 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
817 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
818 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
819 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
820 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
821 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
822 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
823 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
824 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
825 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
826 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
827 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
828 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
831 static const uint8_t AES_CBC_ciphertext_1024B[] = {
832 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
833 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
834 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
835 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
836 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
837 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
838 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
839 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
840 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
841 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
842 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
843 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
844 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
845 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
846 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
847 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
848 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
849 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
850 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
851 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
852 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
853 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
854 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
855 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
856 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
857 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
858 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
859 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
860 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
861 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
862 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
863 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
864 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
865 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
866 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
867 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
868 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
869 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
870 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
871 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
872 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
873 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
874 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
875 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
876 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
877 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
878 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
879 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
880 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
881 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
882 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
883 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
884 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
885 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
886 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
887 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
888 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
889 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
890 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
891 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
892 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
893 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
894 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
895 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
896 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
897 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
898 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
899 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
900 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
901 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
902 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
903 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
904 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
905 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
906 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
907 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
908 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
909 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
910 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
911 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
912 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
913 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
914 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
915 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
916 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
917 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
918 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
919 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
920 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
921 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
922 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
923 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
924 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
925 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
926 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
927 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
928 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
929 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
930 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
931 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
932 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
933 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
934 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
935 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
936 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
937 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
938 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
939 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
940 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
941 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
942 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
943 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
944 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
945 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
946 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
947 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
948 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
949 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
950 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
951 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
952 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
953 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
954 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
955 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
956 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
957 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
958 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
959 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
962 static const uint8_t AES_CBC_ciphertext_1280B[] = {
963 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
964 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
965 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
966 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
967 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
968 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
969 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
970 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
971 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
972 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
973 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
974 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
975 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
976 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
977 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
978 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
979 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
980 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
981 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
982 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
983 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
984 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
985 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
986 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
987 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
988 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
989 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
990 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
991 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
992 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
993 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
994 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
995 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
996 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
997 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
998 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
999 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
1000 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1001 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1002 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1003 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1004 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1005 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1006 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1007 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1008 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1009 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1010 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1011 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1012 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1013 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1014 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1015 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1016 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1017 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1018 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1019 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1020 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1021 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1022 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1023 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1024 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1025 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1026 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1027 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1028 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1029 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1030 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1031 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1032 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1033 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1034 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1035 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1036 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1037 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1038 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1039 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1040 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1041 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1042 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1043 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1044 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1045 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1046 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1047 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1048 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1049 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1050 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1051 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1052 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1053 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1054 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1055 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1056 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1057 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1058 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1059 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1060 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1061 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1062 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1063 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1064 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1065 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1066 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1067 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1068 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1069 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1070 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1071 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1072 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1073 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1074 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1075 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1076 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1077 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1078 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1079 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1080 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1081 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1082 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1083 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1084 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1085 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1086 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1087 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1088 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1089 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1090 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1091 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1092 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1093 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1094 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1095 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1096 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1097 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1098 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1099 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1100 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1101 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1102 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1103 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1104 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1105 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1106 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1107 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1108 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1109 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1110 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1111 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1112 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1113 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1114 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1115 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1116 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1117 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1118 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1119 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1120 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1121 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1122 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1125 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1126 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1127 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1128 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1129 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1130 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1131 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1132 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1133 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1134 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1135 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1136 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1137 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1138 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1139 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1140 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1141 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1142 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1143 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1144 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1145 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1146 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1147 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1148 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1149 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1150 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1151 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1152 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1153 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1154 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1155 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1156 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1157 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1158 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1159 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1160 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1161 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1162 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1163 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1164 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1165 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1166 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1167 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1168 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1169 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1170 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1171 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1172 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1173 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1174 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1175 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1176 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1177 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1178 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1179 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1180 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1181 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1182 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1183 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1184 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1185 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1186 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1187 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1188 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1189 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1190 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1191 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1192 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1193 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1194 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1195 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1196 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1197 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1198 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1199 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1200 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1201 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1202 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1203 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1204 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1205 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1206 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1207 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1208 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1209 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1210 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1211 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1212 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1213 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1214 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1215 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1216 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1217 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1218 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1219 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1220 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1221 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1222 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1223 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1224 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1225 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1226 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1227 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1228 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1229 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1230 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1231 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1232 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1233 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1234 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1235 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1236 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1237 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1238 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1239 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1240 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1241 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1242 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1243 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1244 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1245 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1246 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1247 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1248 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1249 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1250 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1251 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1252 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1253 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1254 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1255 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1256 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1257 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1258 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1259 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1260 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1261 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1262 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1263 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1264 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1265 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1266 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1267 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1268 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1269 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1270 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1271 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1272 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1273 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1274 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1275 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1276 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1277 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1278 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1279 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1280 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1281 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1282 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1283 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1284 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1285 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1286 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1287 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1288 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1289 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1290 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1291 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1292 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1293 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1294 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1295 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1296 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1297 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1298 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1299 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1300 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1301 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1302 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1303 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1304 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1305 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1306 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1307 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1308 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1309 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1310 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1311 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1312 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1313 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1314 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1315 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1316 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1317 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1320 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1321 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1322 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1323 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1324 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1325 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1326 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1327 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1328 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1329 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1330 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1331 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1332 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1333 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1334 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1335 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1336 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1337 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1338 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1339 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1340 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1341 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1342 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1343 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1344 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1345 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1346 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1347 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1348 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1349 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1350 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1351 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1352 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1353 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1354 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1355 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1356 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1357 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1358 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1359 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1360 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1361 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1362 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1363 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1364 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1365 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1366 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1367 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1368 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1369 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1370 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1371 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1372 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1373 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1374 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1375 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1376 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1377 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1378 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1379 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1380 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1381 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1382 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1383 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1384 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1385 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1386 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1387 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1388 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1389 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1390 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1391 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1392 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1393 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1394 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1395 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1396 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1397 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1398 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1399 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1400 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1401 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1402 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1403 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1404 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1405 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1406 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1407 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1408 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1409 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1410 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1411 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1412 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1413 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1414 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1415 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1416 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1417 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1418 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1419 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1420 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1421 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1422 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1423 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1424 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1425 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1426 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1427 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1428 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1429 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1430 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1431 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1432 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1433 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1434 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1435 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1436 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1437 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1438 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1439 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1440 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1441 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1442 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1443 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1444 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1445 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1446 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1447 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1448 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1449 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1450 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1451 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1452 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1453 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1454 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1455 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1456 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1457 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1458 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1459 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1460 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1461 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1462 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1463 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1464 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1465 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1466 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1467 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1468 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1469 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1470 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1471 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1472 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1473 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1474 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1475 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1476 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1477 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1478 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1479 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1480 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1481 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1482 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1483 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1484 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1485 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1486 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1487 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1488 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1489 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1490 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1491 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1492 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1493 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1494 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1495 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1496 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1497 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1498 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1499 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1500 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1501 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1502 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1503 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1504 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1505 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1506 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1507 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1508 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1509 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1510 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1511 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1512 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1513 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1514 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1515 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1516 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1517 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1518 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1519 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1520 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1521 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1522 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1523 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1524 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1525 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1526 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1527 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1528 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1529 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1530 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1531 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1532 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1533 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1534 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1535 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1536 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1537 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1538 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1539 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1540 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1541 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1542 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1543 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1544 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1547 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1548 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1549 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1550 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1551 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1552 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1553 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1554 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1555 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1556 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1557 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1558 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1559 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1560 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1561 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1562 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1563 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1564 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1565 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1566 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1567 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1568 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1569 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1570 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1571 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1572 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1573 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1574 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1575 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1576 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1577 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1578 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1579 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1580 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1581 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1582 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1583 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1584 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1585 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1586 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1587 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1588 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1589 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1590 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1591 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1592 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1593 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1594 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1595 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1596 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1597 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1598 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1599 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1600 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1601 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1602 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1603 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1604 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1605 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1606 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1607 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1608 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1609 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1610 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1611 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1612 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1613 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1614 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1615 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1616 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1617 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1618 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1619 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1620 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1621 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1622 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1623 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1624 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1625 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1626 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1627 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1628 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1629 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1630 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1631 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1632 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1633 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1634 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1635 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1636 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1637 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1638 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1639 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1640 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1641 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1642 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1643 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1644 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1645 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1646 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1647 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1648 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1649 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1650 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1651 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1652 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1653 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1654 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1655 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1656 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1657 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1658 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1659 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1660 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1661 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1662 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1663 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1664 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1665 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1666 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1667 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1668 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1669 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1670 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1671 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1672 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1673 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1674 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1675 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1676 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1677 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1678 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1679 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1680 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1681 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1682 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1683 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1684 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1685 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1686 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1687 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1688 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1689 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1690 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1691 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1692 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1693 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1694 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1695 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1696 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1697 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1698 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1699 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1700 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1701 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1702 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1703 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1704 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1705 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1706 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1707 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1708 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1709 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1710 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1711 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1712 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1713 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1714 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1715 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1716 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1717 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1718 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1719 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1720 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1721 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1722 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1723 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1724 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1725 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1726 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1727 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1728 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1729 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1730 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1731 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1732 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1733 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1734 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1735 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1736 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1737 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1738 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1739 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1740 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1741 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1742 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1743 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1744 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1745 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1746 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1747 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1748 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1749 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1750 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1751 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1752 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1753 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1754 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1755 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1756 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1757 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1758 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1759 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1760 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1761 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1762 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1763 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1764 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1765 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1766 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1767 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1768 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1769 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1770 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1771 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1772 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1773 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1774 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1775 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1776 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1777 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1778 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1779 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1780 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1781 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1782 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1783 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1784 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1785 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1786 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1787 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1788 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1789 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1790 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1791 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1792 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1793 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1794 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1795 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1796 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1797 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1798 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1799 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1800 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1801 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1802 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1803 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1807 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1808 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1809 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1810 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1811 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1814 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1815 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1816 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1817 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1818 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1821 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1822 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1823 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1824 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1825 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1828 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1829 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1830 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1831 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1832 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1835 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1836 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1837 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1838 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1839 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1842 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1843 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1844 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1845 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1846 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1849 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1850 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1851 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1852 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1853 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1856 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1857 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1858 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1859 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1860 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1863 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1864 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1865 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1866 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1867 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1870 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1871 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1872 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1873 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1874 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1877 struct crypto_data_params {
1880 const char *plaintext;
1881 struct crypto_expected_output {
1882 const uint8_t *ciphertext;
1883 const uint8_t *digest;
1887 #define MAX_PACKET_SIZE_INDEX 10
1889 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1890 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1891 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1892 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1893 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1894 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1895 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1896 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1897 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1898 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1899 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1900 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1901 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1902 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1903 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1904 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1905 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1906 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1907 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1908 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1909 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1913 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1915 uint32_t num_to_submit = 4096;
1916 struct rte_crypto_op *c_ops[num_to_submit];
1917 struct rte_crypto_op *proc_ops[num_to_submit];
1918 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1919 uint32_t burst_sent, burst_received;
1920 uint32_t i, burst_size, num_sent, num_received;
1921 struct crypto_testsuite_params *ts_params = &testsuite_params;
1922 struct crypto_unittest_params *ut_params = &unittest_params;
1923 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1925 if (rte_cryptodev_count() == 0) {
1926 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1930 /* Setup Cipher Parameters */
1931 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1932 ut_params->cipher_xform.next = &ut_params->auth_xform;
1934 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1935 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1936 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1937 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1938 ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1939 ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1941 /* Setup HMAC Parameters */
1942 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1943 ut_params->auth_xform.next = NULL;
1945 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1946 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1947 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1948 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1949 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1951 /* Create Crypto session*/
1952 ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
1953 &ut_params->cipher_xform);
1955 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1957 /* Generate Crypto op data structure(s) */
1958 for (i = 0; i < num_to_submit ; i++) {
1959 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
1960 data_params[0].expected.ciphertext,
1961 data_params[0].length, 0);
1962 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
1964 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
1965 DIGEST_BYTE_LENGTH_SHA256);
1966 TEST_ASSERT_NOT_NULL(ut_params->digest,
1967 "no room to append digest");
1969 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1970 DIGEST_BYTE_LENGTH_SHA256);
1973 struct rte_crypto_op *op =
1974 rte_crypto_op_alloc(ts_params->op_mpool,
1975 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1977 rte_crypto_op_attach_sym_session(op, ut_params->sess);
1979 op->sym->auth.digest.data = ut_params->digest;
1980 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
1981 data_params[0].length);
1982 op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1984 op->sym->auth.data.offset = 0;
1985 op->sym->auth.data.length = data_params[0].length;
1987 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
1988 aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
1990 op->sym->cipher.data.offset = 0;
1991 op->sym->cipher.data.length = data_params[0].length;
1998 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
1999 "algorithm with a constant request size of %u.",
2000 data_params[0].length);
2001 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2002 "cost for each request.");
2003 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2004 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2005 "(assuming 0 retries)");
2006 for (i = 2; i <= 128 ; i *= 2) {
2013 while (num_sent < num_to_submit) {
2014 start_cycles = rte_rdtsc_precise();
2015 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2016 0, &c_ops[num_sent],
2017 ((num_to_submit-num_sent) < burst_size) ?
2018 num_to_submit-num_sent : burst_size);
2019 if (burst_sent == 0)
2022 num_sent += burst_sent;
2023 end_cycles = rte_rdtsc_precise();
2024 total_cycles += (end_cycles - start_cycles);
2026 * Wait until requests have been sent.
2030 start_cycles = rte_rdtsc_precise();
2031 burst_received = rte_cryptodev_dequeue_burst(
2032 dev_num, 0, proc_ops, burst_size);
2033 if (burst_received == 0)
2036 num_received += burst_received;
2037 end_cycles = rte_rdtsc_precise();
2038 total_cycles += end_cycles - start_cycles;
2041 while (num_received != num_to_submit) {
2042 if (gbl_cryptodev_perftest_devtype ==
2043 RTE_CRYPTODEV_AESNI_MB_PMD)
2044 rte_cryptodev_enqueue_burst(dev_num, 0,
2047 burst_received = rte_cryptodev_dequeue_burst(
2048 dev_num, 0, proc_ops, burst_size);
2049 if (burst_received == 0)
2052 num_received += burst_received;
2055 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2056 num_sent, num_received, burst_size);
2057 printf("\t\t%"PRIu64, retries);
2058 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2062 for (i = 0; i < num_to_submit ; i++) {
2063 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2064 rte_crypto_op_free(c_ops[i]);
2066 return TEST_SUCCESS;
2070 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2072 uint32_t num_to_submit = pparams->total_operations;
2073 struct rte_crypto_op *c_ops[num_to_submit];
2074 struct rte_crypto_op *proc_ops[num_to_submit];
2075 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2076 uint32_t burst_sent = 0, burst_received = 0;
2077 uint32_t i, burst_size, num_sent, num_ops_received;
2078 struct crypto_testsuite_params *ts_params = &testsuite_params;
2079 static struct rte_cryptodev_sym_session *sess;
2081 if (rte_cryptodev_count() == 0) {
2082 printf("\nNo crypto devices found. Is PMD build configured?\n");
2083 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2087 /* Create Crypto session*/
2088 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2089 pparams->chain, pparams->cipher_algo,
2090 pparams->cipher_key_length, pparams->auth_algo);
2091 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2093 /* Generate Crypto op data structure(s)*/
2094 for (i = 0; i < num_to_submit ; i++) {
2095 struct rte_mbuf *m = test_perf_create_pktmbuf(
2098 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2100 struct rte_crypto_op *op =
2101 rte_crypto_op_alloc(ts_params->op_mpool,
2102 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2103 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2105 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size,
2106 get_auth_digest_length(pparams->auth_algo));
2107 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2112 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2113 "Packet Size %u bytes",
2114 pmd_name(gbl_cryptodev_perftest_devtype),
2115 ts_params->dev_id, 0,
2116 chain_mode_name(pparams->chain),
2117 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2118 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2120 printf("\nOps Tx\tOps Rx\tOps/burst ");
2121 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2123 for (i = 2; i <= 128 ; i *= 2) {
2125 num_ops_received = 0;
2130 while (num_sent < num_to_submit) {
2131 start_cycles = rte_rdtsc_precise();
2132 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2133 0, &c_ops[num_sent],
2134 ((num_to_submit-num_sent) < burst_size) ?
2135 num_to_submit-num_sent : burst_size);
2136 end_cycles = rte_rdtsc_precise();
2137 if (burst_sent == 0)
2139 num_sent += burst_sent;
2140 total_cycles += (end_cycles - start_cycles);
2142 /* Wait until requests have been sent. */
2146 start_cycles = rte_rdtsc_precise();
2147 burst_received = rte_cryptodev_dequeue_burst(
2148 ts_params->dev_id, 0, proc_ops, burst_size);
2149 end_cycles = rte_rdtsc_precise();
2150 if (burst_received < burst_sent)
2152 num_ops_received += burst_received;
2154 total_cycles += end_cycles - start_cycles;
2157 while (num_ops_received != num_to_submit) {
2158 if (gbl_cryptodev_perftest_devtype ==
2159 RTE_CRYPTODEV_AESNI_MB_PMD)
2160 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2162 start_cycles = rte_rdtsc_precise();
2163 burst_received = rte_cryptodev_dequeue_burst(
2164 ts_params->dev_id, 0, proc_ops, burst_size);
2165 end_cycles = rte_rdtsc_precise();
2166 total_cycles += end_cycles - start_cycles;
2167 if (burst_received == 0)
2169 num_ops_received += burst_received;
2172 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2173 printf("\t\t%"PRIu64, retries);
2174 printf("\t%"PRIu64, failed_polls);
2175 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2176 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2177 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2181 for (i = 0; i < num_to_submit ; i++) {
2182 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2183 rte_crypto_op_free(c_ops[i]);
2185 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2187 return TEST_SUCCESS;
2191 test_perf_snow3G_vary_burst_size(void)
2193 unsigned total_operations = 4096;
2194 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2195 uint16_t buf_lengths[] = {40};
2198 struct perf_test_params params_set[] = {
2200 .chain = CIPHER_ONLY,
2201 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2202 .cipher_key_length = 16,
2203 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2207 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2208 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2209 .cipher_key_length = 16
2213 printf("\n\nStart %s.", __func__);
2214 printf("\nThis Test measures the average IA cycle cost using a "
2215 "constant request(packet) size. ");
2216 printf("Cycle cost is only valid when indicators show device is not busy,"
2217 " i.e. Retries and EmptyPolls = 0");
2219 for (i = 0; i < RTE_DIM(params_set); i++) {
2221 params_set[i].total_operations = total_operations;
2224 j < RTE_DIM(buf_lengths);
2227 params_set[i].buf_size = buf_lengths[j];
2229 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2238 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2240 uint32_t num_to_submit = pparams->total_operations;
2241 struct rte_crypto_op *c_ops[num_to_submit];
2242 struct rte_crypto_op *proc_ops[num_to_submit];
2243 uint64_t failed_polls, retries, start_cycles,
2244 end_cycles, total_cycles = 0;
2245 uint32_t burst_sent = 0, burst_received = 0;
2246 uint32_t i, burst_size, num_sent, num_ops_received;
2248 struct crypto_testsuite_params *ts_params = &testsuite_params;
2250 static struct rte_cryptodev_sym_session *sess;
2252 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2253 (struct rte_crypto_op *, struct rte_mbuf *,
2254 struct rte_cryptodev_sym_session *,
2255 unsigned int, unsigned int,
2258 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2260 if (rte_cryptodev_count() == 0) {
2261 printf("\nNo crypto devices found. Is PMD build configured?\n");
2265 /* Create Crypto session*/
2266 sess = test_perf_create_openssl_session(ts_params->dev_id,
2267 pparams->chain, pparams->cipher_algo,
2268 pparams->cipher_key_length, pparams->auth_algo);
2269 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2271 /* Generate Crypto op data structure(s)*/
2272 for (i = 0; i < num_to_submit ; i++) {
2273 struct rte_mbuf *m = test_perf_create_pktmbuf(
2276 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2278 struct rte_crypto_op *op =
2279 rte_crypto_op_alloc(ts_params->op_mpool,
2280 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2281 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2283 switch (pparams->cipher_algo) {
2284 case RTE_CRYPTO_CIPHER_3DES_CBC:
2285 case RTE_CRYPTO_CIPHER_3DES_CTR:
2286 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2288 case RTE_CRYPTO_CIPHER_AES_CBC:
2289 case RTE_CRYPTO_CIPHER_AES_CTR:
2290 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2292 case RTE_CRYPTO_CIPHER_AES_GCM:
2293 test_perf_set_crypto_op =
2294 test_perf_set_crypto_op_aes_gcm;
2300 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2301 digest_length, pparams->chain);
2302 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2307 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2308 "auth_algo:%s, Packet Size %u bytes",
2309 pmd_name(gbl_cryptodev_perftest_devtype),
2310 ts_params->dev_id, 0,
2311 chain_mode_name(pparams->chain),
2312 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2313 pparams->cipher_key_length,
2314 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2316 printf("\nOps Tx\tOps Rx\tOps/burst ");
2317 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2320 for (i = 2; i <= 128 ; i *= 2) {
2322 num_ops_received = 0;
2327 while (num_sent < num_to_submit) {
2328 start_cycles = rte_rdtsc_precise();
2329 burst_sent = rte_cryptodev_enqueue_burst(
2331 0, &c_ops[num_sent],
2332 ((num_to_submit - num_sent) <
2334 num_to_submit - num_sent : burst_size);
2335 end_cycles = rte_rdtsc_precise();
2336 if (burst_sent == 0)
2338 num_sent += burst_sent;
2339 total_cycles += (end_cycles - start_cycles);
2341 /* Wait until requests have been sent. */
2344 start_cycles = rte_rdtsc_precise();
2345 burst_received = rte_cryptodev_dequeue_burst(
2346 ts_params->dev_id, 0, proc_ops,
2348 end_cycles = rte_rdtsc_precise();
2349 if (burst_received < burst_sent)
2351 num_ops_received += burst_received;
2353 total_cycles += end_cycles - start_cycles;
2356 while (num_ops_received != num_to_submit) {
2357 /* Sending 0 length burst to flush sw crypto device */
2358 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2361 start_cycles = rte_rdtsc_precise();
2362 burst_received = rte_cryptodev_dequeue_burst(
2363 ts_params->dev_id, 0, proc_ops,
2365 end_cycles = rte_rdtsc_precise();
2367 total_cycles += end_cycles - start_cycles;
2368 if (burst_received == 0)
2370 num_ops_received += burst_received;
2373 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2374 printf("\t\t%"PRIu64, retries);
2375 printf("\t%"PRIu64, failed_polls);
2376 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2377 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2379 printf("\t\t%"PRIu64,
2381 (num_ops_received * pparams->buf_size));
2385 for (i = 0; i < num_to_submit ; i++) {
2386 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2387 rte_crypto_op_free(c_ops[i]);
2389 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2391 return TEST_SUCCESS;
2395 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2397 uint32_t num_to_submit = pparams->total_operations;
2398 struct rte_crypto_op *c_ops[num_to_submit];
2399 struct rte_crypto_op *proc_ops[num_to_submit];
2400 uint64_t failed_polls, retries, start_cycles, end_cycles,
2402 uint32_t burst_sent = 0, burst_received = 0;
2403 uint32_t i, burst_size, num_sent, num_ops_received;
2406 struct crypto_testsuite_params *ts_params = &testsuite_params;
2408 static struct rte_cryptodev_sym_session *sess;
2410 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2412 if (rte_cryptodev_count() == 0) {
2413 printf("\nNo crypto devices found. Is PMD build configured?\n");
2417 /* Create Crypto session*/
2418 sess = test_perf_create_armv8_session(ts_params->dev_id,
2419 pparams->chain, pparams->cipher_algo,
2420 pparams->cipher_key_length, pparams->auth_algo);
2421 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2423 /* Generate Crypto op data structure(s)*/
2424 for (i = 0; i < num_to_submit ; i++) {
2425 struct rte_mbuf *m = test_perf_create_pktmbuf(
2428 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2430 struct rte_crypto_op *op =
2431 rte_crypto_op_alloc(ts_params->op_mpool,
2432 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2433 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2435 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2436 digest_length, pparams->chain);
2437 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2442 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2443 "auth_algo:%s, Packet Size %u bytes",
2444 pmd_name(gbl_cryptodev_perftest_devtype),
2445 ts_params->dev_id, 0,
2446 chain_mode_name(pparams->chain),
2447 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2448 pparams->cipher_key_length,
2449 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2451 printf("\nOps Tx\tOps Rx\tOps/burst ");
2453 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2455 for (i = 2; i <= 128 ; i *= 2) {
2457 num_ops_received = 0;
2462 while (num_sent < num_to_submit) {
2463 if ((num_to_submit - num_sent) < burst_size)
2464 nb_ops = num_to_submit - num_sent;
2466 nb_ops = burst_size;
2468 start_cycles = rte_rdtsc();
2469 burst_sent = rte_cryptodev_enqueue_burst(
2471 0, &c_ops[num_sent],
2473 end_cycles = rte_rdtsc();
2475 if (burst_sent == 0)
2477 num_sent += burst_sent;
2478 total_cycles += (end_cycles - start_cycles);
2480 start_cycles = rte_rdtsc();
2481 burst_received = rte_cryptodev_dequeue_burst(
2482 ts_params->dev_id, 0, proc_ops,
2484 end_cycles = rte_rdtsc();
2485 if (burst_received < burst_sent)
2487 num_ops_received += burst_received;
2489 total_cycles += end_cycles - start_cycles;
2492 while (num_ops_received != num_to_submit) {
2493 /* Sending 0 length burst to flush sw crypto device */
2494 rte_cryptodev_enqueue_burst(
2495 ts_params->dev_id, 0, NULL, 0);
2497 start_cycles = rte_rdtsc();
2498 burst_received = rte_cryptodev_dequeue_burst(
2499 ts_params->dev_id, 0, proc_ops, burst_size);
2500 end_cycles = rte_rdtsc();
2502 total_cycles += end_cycles - start_cycles;
2503 if (burst_received == 0)
2505 num_ops_received += burst_received;
2508 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2509 printf("\t\t%"PRIu64, retries);
2510 printf("\t%"PRIu64, failed_polls);
2511 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2512 printf("\t\t%"PRIu64,
2513 (total_cycles/num_ops_received)*burst_size);
2514 printf("\t\t%"PRIu64,
2515 total_cycles/(num_ops_received*pparams->buf_size));
2519 for (i = 0; i < num_to_submit ; i++) {
2520 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2521 rte_crypto_op_free(c_ops[i]);
2524 return TEST_SUCCESS;
2527 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2530 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2532 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2534 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2536 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2538 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2540 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2542 case RTE_CRYPTO_AUTH_AES_GCM:
2549 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2552 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2554 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2555 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2556 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2557 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2558 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2559 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2560 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2561 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2562 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2563 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2564 case RTE_CRYPTO_AUTH_AES_GCM:
2565 return DIGEST_BYTE_LENGTH_AES_GCM;
2571 static uint8_t aes_key[] = {
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,
2575 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2578 static uint8_t aes_iv[] = {
2579 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2580 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2583 static uint8_t aes_gcm_aad[] = {
2584 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2585 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2588 static uint8_t triple_des_key[] = {
2589 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2590 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2591 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2594 static uint8_t triple_des_iv[] = {
2595 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2598 static uint8_t hmac_sha_key[] = {
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,
2614 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2617 static uint8_t snow3g_cipher_key[] = {
2618 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2619 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2622 static uint8_t snow3g_iv[] = {
2623 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2624 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2627 static uint8_t snow3g_hash_key[] = {
2628 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2629 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2632 static struct rte_cryptodev_sym_session *
2633 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2634 enum rte_crypto_cipher_algorithm cipher_algo,
2635 unsigned cipher_key_len,
2636 enum rte_crypto_auth_algorithm auth_algo)
2638 struct rte_crypto_sym_xform cipher_xform = { 0 };
2639 struct rte_crypto_sym_xform auth_xform = { 0 };
2642 /* Setup Cipher Parameters */
2643 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2644 cipher_xform.cipher.algo = cipher_algo;
2645 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2647 cipher_xform.cipher.key.data = aes_key;
2648 cipher_xform.cipher.key.length = cipher_key_len;
2649 cipher_xform.cipher.iv.offset = IV_OFFSET;
2650 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2651 if (chain != CIPHER_ONLY) {
2652 /* Setup HMAC Parameters */
2653 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2654 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2655 auth_xform.auth.algo = auth_algo;
2656 auth_xform.auth.key.data = hmac_sha_key;
2657 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2658 auth_xform.auth.digest_length =
2659 get_auth_digest_length(auth_algo);
2663 cipher_xform.next = &auth_xform;
2664 auth_xform.next = NULL;
2665 /* Create Crypto session*/
2666 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2668 auth_xform.next = &cipher_xform;
2669 cipher_xform.next = NULL;
2670 /* Create Crypto session*/
2671 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2673 cipher_xform.next = NULL;
2674 /* Create Crypto session*/
2675 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2681 #define SNOW3G_CIPHER_IV_LENGTH 16
2683 static struct rte_cryptodev_sym_session *
2684 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2685 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2686 enum rte_crypto_auth_algorithm auth_algo)
2688 struct rte_crypto_sym_xform cipher_xform = {0};
2689 struct rte_crypto_sym_xform auth_xform = {0};
2692 /* Setup Cipher Parameters */
2693 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2694 cipher_xform.cipher.algo = cipher_algo;
2695 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2697 cipher_xform.cipher.key.data = snow3g_cipher_key;
2698 cipher_xform.cipher.key.length = cipher_key_len;
2699 cipher_xform.cipher.iv.offset = IV_OFFSET;
2700 cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2703 /* Setup HMAC Parameters */
2704 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2705 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2706 auth_xform.auth.algo = auth_algo;
2708 auth_xform.auth.key.data = snow3g_hash_key;
2709 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2710 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2711 /* Auth IV will be after cipher IV */
2712 auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
2713 auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2717 cipher_xform.next = &auth_xform;
2718 auth_xform.next = NULL;
2719 /* Create Crypto session*/
2720 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2722 auth_xform.next = &cipher_xform;
2723 cipher_xform.next = NULL;
2724 /* Create Crypto session*/
2725 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2727 cipher_xform.next = NULL;
2728 /* Create Crypto session*/
2729 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2731 auth_xform.next = NULL;
2732 /* Create Crypto session */
2733 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2739 static struct rte_cryptodev_sym_session *
2740 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2741 enum rte_crypto_cipher_algorithm cipher_algo,
2742 unsigned int cipher_key_len,
2743 enum rte_crypto_auth_algorithm auth_algo)
2745 struct rte_crypto_sym_xform cipher_xform = { 0 };
2746 struct rte_crypto_sym_xform auth_xform = { 0 };
2748 /* Setup Cipher Parameters */
2749 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2750 cipher_xform.cipher.algo = cipher_algo;
2751 cipher_xform.cipher.iv.offset = IV_OFFSET;
2752 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2754 switch (cipher_algo) {
2755 case RTE_CRYPTO_CIPHER_3DES_CBC:
2756 case RTE_CRYPTO_CIPHER_3DES_CTR:
2757 cipher_xform.cipher.key.data = triple_des_key;
2758 cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2760 case RTE_CRYPTO_CIPHER_AES_CBC:
2761 case RTE_CRYPTO_CIPHER_AES_CTR:
2762 case RTE_CRYPTO_CIPHER_AES_GCM:
2763 cipher_xform.cipher.key.data = aes_key;
2764 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2770 cipher_xform.cipher.key.length = cipher_key_len;
2772 /* Setup Auth Parameters */
2773 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2774 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2775 auth_xform.auth.algo = auth_algo;
2777 switch (auth_algo) {
2778 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2779 auth_xform.auth.key.data = hmac_sha_key;
2781 case RTE_CRYPTO_AUTH_AES_GCM:
2782 auth_xform.auth.key.data = NULL;
2783 auth_xform.auth.add_auth_data_length = AES_GCM_AAD_LENGTH;
2789 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2790 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2794 cipher_xform.next = &auth_xform;
2795 auth_xform.next = NULL;
2796 /* Create Crypto session*/
2797 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2799 auth_xform.next = &cipher_xform;
2800 cipher_xform.next = NULL;
2801 /* Create Crypto session*/
2802 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2808 static struct rte_cryptodev_sym_session *
2809 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2810 enum rte_crypto_cipher_algorithm cipher_algo,
2811 unsigned int cipher_key_len,
2812 enum rte_crypto_auth_algorithm auth_algo)
2814 struct rte_crypto_sym_xform cipher_xform = { 0 };
2815 struct rte_crypto_sym_xform auth_xform = { 0 };
2817 /* Setup Cipher Parameters */
2818 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2819 cipher_xform.cipher.algo = cipher_algo;
2821 switch (cipher_algo) {
2822 case RTE_CRYPTO_CIPHER_AES_CBC:
2823 cipher_xform.cipher.key.data = aes_cbc_128_key;
2829 cipher_xform.cipher.key.length = cipher_key_len;
2830 cipher_xform.cipher.iv.offset = IV_OFFSET;
2831 cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2833 /* Setup Auth Parameters */
2834 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2835 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2836 auth_xform.auth.algo = auth_algo;
2838 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2842 cipher_xform.next = &auth_xform;
2843 auth_xform.next = NULL;
2844 /* Encrypt and hash the result */
2845 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2846 /* Create Crypto session*/
2847 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2849 auth_xform.next = &cipher_xform;
2850 cipher_xform.next = NULL;
2851 /* Hash encrypted message and decrypt */
2852 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2853 /* Create Crypto session*/
2854 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
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.data.offset = 0;
2892 op->sym->auth.data.length = 0;
2894 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2895 uint8_t *, data_len);
2896 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2898 op->sym->auth.digest.length = digest_len;
2899 op->sym->auth.data.offset = 0;
2900 op->sym->auth.data.length = data_len;
2904 /* Copy the IV at the end of the crypto operation */
2905 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2906 aes_iv, AES_CIPHER_IV_LENGTH);
2908 /* Cipher Parameters */
2909 op->sym->cipher.data.offset = 0;
2910 op->sym->cipher.data.length = data_len;
2917 static inline struct rte_crypto_op *
2918 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2919 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2920 unsigned int digest_len, enum chain_mode chain __rte_unused)
2922 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2923 rte_crypto_op_free(op);
2927 /* Authentication Parameters */
2928 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2929 (m->data_off + data_len);
2930 op->sym->auth.digest.phys_addr =
2931 rte_pktmbuf_mtophys_offset(m, data_len);
2932 op->sym->auth.digest.length = digest_len;
2933 op->sym->auth.aad.data = aes_gcm_aad;
2935 /* Copy IV at the end of the crypto operation */
2936 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2937 aes_iv, AES_CIPHER_IV_LENGTH);
2939 /* Data lengths/offsets Parameters */
2940 op->sym->auth.data.offset = 0;
2941 op->sym->auth.data.length = data_len;
2943 op->sym->cipher.data.offset = 0;
2944 op->sym->cipher.data.length = data_len;
2951 static inline struct rte_crypto_op *
2952 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2953 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2954 unsigned digest_len)
2956 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
2957 uint8_t *, IV_OFFSET);
2959 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2960 rte_crypto_op_free(op);
2964 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2966 /* Authentication Parameters */
2967 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2968 (m->data_off + data_len);
2969 op->sym->auth.digest.phys_addr =
2970 rte_pktmbuf_mtophys_offset(m, data_len);
2971 op->sym->auth.digest.length = digest_len;
2973 /* Data lengths/offsets Parameters */
2974 op->sym->auth.data.offset = 0;
2975 op->sym->auth.data.length = data_len << 3;
2977 op->sym->cipher.data.offset = 0;
2978 op->sym->cipher.data.length = data_len << 3;
2985 static inline struct rte_crypto_op *
2986 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2988 struct rte_cryptodev_sym_session *sess,
2991 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2992 rte_crypto_op_free(op);
2996 /* Copy IV at the end of the crypto operation */
2997 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2998 snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3000 /* Cipher Parameters */
3001 op->sym->cipher.data.offset = 0;
3002 op->sym->cipher.data.length = data_len << 3;
3004 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3006 SNOW3G_CIPHER_IV_LENGTH);
3014 static inline struct rte_crypto_op *
3015 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3017 struct rte_cryptodev_sym_session *sess,
3019 unsigned digest_len)
3021 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3022 uint8_t *, IV_OFFSET);
3024 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3025 rte_crypto_op_free(op);
3029 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3031 /* Authentication Parameters */
3033 op->sym->auth.digest.data =
3034 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3036 op->sym->auth.digest.phys_addr =
3037 rte_pktmbuf_mtophys_offset(m, data_len +
3038 SNOW3G_CIPHER_IV_LENGTH);
3039 op->sym->auth.digest.length = digest_len;
3041 /* Data lengths/offsets Parameters */
3042 op->sym->auth.data.offset = 0;
3043 op->sym->auth.data.length = data_len << 3;
3051 static inline struct rte_crypto_op *
3052 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3053 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3054 unsigned int digest_len, enum chain_mode chain __rte_unused)
3056 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3057 rte_crypto_op_free(op);
3061 /* Authentication Parameters */
3062 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3063 (m->data_off + data_len);
3064 op->sym->auth.digest.phys_addr =
3065 rte_pktmbuf_mtophys_offset(m, data_len);
3066 op->sym->auth.digest.length = digest_len;
3068 /* Copy IV at the end of the crypto operation */
3069 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3070 triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3072 /* Data lengths/offsets Parameters */
3073 op->sym->auth.data.offset = 0;
3074 op->sym->auth.data.length = data_len;
3076 op->sym->cipher.data.offset = 0;
3077 op->sym->cipher.data.length = data_len;
3084 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3085 * same time, i.e. as they're not dereferenced there's no need to wait until
3086 * finished with to re-use */
3087 #define NUM_MBUF_SETS 8
3090 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3091 struct perf_test_params *pparams)
3093 uint16_t i, k, l, m;
3095 uint16_t ops_unused = 0;
3097 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3098 uint64_t processed = 0, failed_polls = 0, retries = 0;
3099 uint64_t tsc_start = 0, tsc_end = 0;
3101 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3103 struct rte_crypto_op *ops[pparams->burst_size];
3104 struct rte_crypto_op *proc_ops[pparams->burst_size];
3106 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3108 struct crypto_testsuite_params *ts_params = &testsuite_params;
3110 static struct rte_cryptodev_sym_session *sess;
3112 if (rte_cryptodev_count() == 0) {
3113 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3117 /* Create Crypto session*/
3118 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3119 pparams->chain, pparams->cipher_algo,
3120 pparams->cipher_key_length, pparams->auth_algo);
3121 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3123 /* Generate a burst of crypto operations */
3124 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3125 mbufs[i] = test_perf_create_pktmbuf(
3129 if (mbufs[i] == NULL) {
3130 printf("\nFailed to get mbuf - freeing the rest.\n");
3131 for (k = 0; k < i; k++)
3132 rte_pktmbuf_free(mbufs[k]);
3136 /* Make room for Digest in mbuf */
3137 if (pparams->chain != CIPHER_ONLY)
3138 rte_pktmbuf_append(mbufs[i], digest_length);
3142 tsc_start = rte_rdtsc_precise();
3144 while (total_enqueued < pparams->total_operations) {
3145 uint16_t burst_size =
3146 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3147 pparams->burst_size : pparams->total_operations-total_enqueued;
3148 uint16_t ops_needed = burst_size-ops_unused;
3150 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3151 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3152 printf("\nFailed to alloc enough ops, finish dequeuing "
3153 "and free ops below.");
3155 for (i = 0; i < ops_needed; i++)
3156 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3157 mbufs[i + (pparams->burst_size *
3158 (j % NUM_MBUF_SETS))],
3159 sess, pparams->buf_size, digest_length,
3163 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3164 queue_id, ops, burst_size);
3166 if (burst_enqueued < burst_size)
3169 ops_unused = burst_size-burst_enqueued;
3170 total_enqueued += burst_enqueued;
3174 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3175 proc_ops, pparams->burst_size);
3176 if (burst_dequeued == 0)
3179 processed += burst_dequeued;
3181 for (l = 0; l < burst_dequeued; l++)
3182 rte_crypto_op_free(proc_ops[l]);
3187 /* Dequeue any operations still in the crypto device */
3188 while (processed < pparams->total_operations) {
3189 /* Sending 0 length burst to flush sw crypto device */
3190 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3193 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3194 proc_ops, pparams->burst_size);
3195 if (burst_dequeued == 0)
3198 processed += burst_dequeued;
3200 for (m = 0; m < burst_dequeued; m++)
3201 rte_crypto_op_free(proc_ops[m]);
3205 tsc_end = rte_rdtsc_precise();
3207 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3208 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3210 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3211 throughput, retries, failed_polls);
3213 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3214 rte_pktmbuf_free(mbufs[i]);
3215 rte_cryptodev_sym_session_free(dev_id, sess);
3218 return TEST_SUCCESS;
3223 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3224 struct perf_test_params *pparams)
3226 uint16_t i, k, l, m;
3228 uint16_t ops_unused = 0;
3229 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3230 uint64_t processed = 0, failed_polls = 0, retries = 0;
3231 uint64_t tsc_start = 0, tsc_end = 0;
3233 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3235 struct rte_crypto_op *ops[pparams->burst_size];
3236 struct rte_crypto_op *proc_ops[pparams->burst_size];
3238 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3240 struct crypto_testsuite_params *ts_params = &testsuite_params;
3242 static struct rte_cryptodev_sym_session *sess;
3244 if (rte_cryptodev_count() == 0) {
3245 printf("\nNo crypto devices found. Is PMD build configured?\n");
3246 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3250 /* Create Crypto session*/
3251 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3252 pparams->chain, pparams->cipher_algo,
3253 pparams->cipher_key_length, pparams->auth_algo);
3254 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3256 /* Generate a burst of crypto operations */
3257 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3259 * Buffer size is allocated, for perf tests they
3260 * are equal + digest len.
3262 mbufs[i] = test_perf_create_pktmbuf(
3267 if (mbufs[i] == NULL) {
3268 printf("\nFailed to get mbuf - freeing the rest.\n");
3269 for (k = 0; k < i; k++)
3270 rte_pktmbuf_free(mbufs[k]);
3276 tsc_start = rte_rdtsc_precise();
3278 while (total_enqueued < pparams->total_operations) {
3279 uint16_t burst_size =
3280 (total_enqueued+pparams->burst_size)
3281 <= pparams->total_operations ?
3282 pparams->burst_size : pparams->total_operations-total_enqueued;
3283 uint16_t ops_needed = burst_size-ops_unused;
3284 /* Handle the last burst correctly */
3285 uint16_t op_offset = pparams->burst_size - burst_size;
3288 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3289 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3290 ops+op_offset, ops_needed)) {
3291 printf("\nFailed to alloc enough ops.");
3292 /*Don't exit, dequeue, more ops should become available*/
3294 for (i = 0; i < ops_needed; i++) {
3295 if (pparams->chain == HASH_ONLY)
3297 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3299 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3301 pparams->buf_size, digest_length);
3302 else if (pparams->chain == CIPHER_ONLY)
3304 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3306 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3315 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3316 ops+op_offset, burst_size);
3318 if (burst_enqueued < burst_size)
3321 ops_unused = burst_size-burst_enqueued;
3322 total_enqueued += burst_enqueued;
3326 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3327 proc_ops, pparams->burst_size);
3328 if (burst_dequeued == 0) {
3331 processed += burst_dequeued;
3332 for (l = 0; l < burst_dequeued; l++)
3333 rte_crypto_op_free(proc_ops[l]);
3338 /* Dequeue any operations still in the crypto device */
3339 while (processed < pparams->total_operations) {
3340 /* Sending 0 length burst to flush sw crypto device */
3341 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3344 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3345 proc_ops, pparams->burst_size);
3346 if (burst_dequeued == 0)
3349 processed += burst_dequeued;
3350 for (m = 0; m < burst_dequeued; m++)
3351 rte_crypto_op_free(proc_ops[m]);
3355 tsc_end = rte_rdtsc_precise();
3357 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3358 double cycles_burst = (double) (tsc_end - tsc_start) /
3359 (double) processed * pparams->burst_size;
3360 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3361 double cycles_B = cycles_buff / pparams->buf_size;
3362 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3364 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3365 /* Cycle count misleading on HW devices for this test, so don't print */
3366 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3367 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3368 pparams->buf_size, ops_s/1000000,
3369 throughput, retries, failed_polls);
3371 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3372 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3373 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3374 cycles_buff, cycles_B, retries, failed_polls);
3377 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3378 rte_pktmbuf_free(mbufs[i]);
3379 rte_cryptodev_sym_session_free(dev_id, sess);
3382 return TEST_SUCCESS;
3386 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3387 struct perf_test_params *pparams)
3389 uint16_t i, k, l, m;
3391 uint16_t ops_unused = 0;
3393 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3394 uint64_t processed = 0, failed_polls = 0, retries = 0;
3395 uint64_t tsc_start = 0, tsc_end = 0;
3397 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3399 struct rte_crypto_op *ops[pparams->burst_size];
3400 struct rte_crypto_op *proc_ops[pparams->burst_size];
3402 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3404 struct crypto_testsuite_params *ts_params = &testsuite_params;
3406 static struct rte_cryptodev_sym_session *sess;
3408 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3409 (struct rte_crypto_op *, struct rte_mbuf *,
3410 struct rte_cryptodev_sym_session *,
3411 unsigned int, unsigned int,
3414 switch (pparams->cipher_algo) {
3415 case RTE_CRYPTO_CIPHER_3DES_CBC:
3416 case RTE_CRYPTO_CIPHER_3DES_CTR:
3417 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3419 case RTE_CRYPTO_CIPHER_AES_CBC:
3420 case RTE_CRYPTO_CIPHER_AES_CTR:
3421 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3423 case RTE_CRYPTO_CIPHER_AES_GCM:
3424 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3430 if (rte_cryptodev_count() == 0) {
3431 printf("\nNo crypto devices found. Is PMD build configured?\n");
3435 /* Create Crypto session*/
3436 sess = test_perf_create_openssl_session(ts_params->dev_id,
3437 pparams->chain, pparams->cipher_algo,
3438 pparams->cipher_key_length, pparams->auth_algo);
3439 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3441 /* Generate a burst of crypto operations */
3442 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3443 mbufs[i] = test_perf_create_pktmbuf(
3447 if (mbufs[i] == NULL) {
3448 printf("\nFailed to get mbuf - freeing the rest.\n");
3449 for (k = 0; k < i; k++)
3450 rte_pktmbuf_free(mbufs[k]);
3455 tsc_start = rte_rdtsc_precise();
3457 while (total_enqueued < pparams->total_operations) {
3458 uint16_t burst_size =
3459 total_enqueued + pparams->burst_size <=
3460 pparams->total_operations ? pparams->burst_size :
3461 pparams->total_operations - total_enqueued;
3462 uint16_t ops_needed = burst_size - ops_unused;
3464 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3465 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3466 printf("\nFailed to alloc enough ops, finish dequeuing "
3467 "and free ops below.");
3469 for (i = 0; i < ops_needed; i++)
3470 ops[i] = test_perf_set_crypto_op(ops[i],
3471 mbufs[i + (pparams->burst_size *
3472 (j % NUM_MBUF_SETS))],
3473 sess, pparams->buf_size, digest_length,
3477 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3478 queue_id, ops, burst_size);
3480 if (burst_enqueued < burst_size)
3483 ops_unused = burst_size - burst_enqueued;
3484 total_enqueued += burst_enqueued;
3488 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3489 proc_ops, pparams->burst_size);
3490 if (burst_dequeued == 0)
3493 processed += burst_dequeued;
3495 for (l = 0; l < burst_dequeued; l++)
3496 rte_crypto_op_free(proc_ops[l]);
3501 /* Dequeue any operations still in the crypto device */
3502 while (processed < pparams->total_operations) {
3503 /* Sending 0 length burst to flush sw crypto device */
3504 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3507 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3508 proc_ops, pparams->burst_size);
3509 if (burst_dequeued == 0)
3512 processed += burst_dequeued;
3514 for (m = 0; m < burst_dequeued; m++)
3515 rte_crypto_op_free(proc_ops[m]);
3519 tsc_end = rte_rdtsc_precise();
3521 double ops_s = ((double)processed / (tsc_end - tsc_start))
3523 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3526 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3527 ops_s / 1000000, throughput, retries, failed_polls);
3529 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3530 rte_pktmbuf_free(mbufs[i]);
3531 rte_cryptodev_sym_session_free(dev_id, sess);
3534 return TEST_SUCCESS;
3538 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3539 struct perf_test_params *pparams)
3541 uint16_t i, k, l, m;
3543 uint16_t ops_unused = 0;
3544 uint16_t burst_size;
3545 uint16_t ops_needed;
3547 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3548 uint64_t processed = 0, failed_polls = 0, retries = 0;
3549 uint64_t tsc_start = 0, tsc_end = 0;
3551 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3553 struct rte_crypto_op *ops[pparams->burst_size];
3554 struct rte_crypto_op *proc_ops[pparams->burst_size];
3556 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3558 struct crypto_testsuite_params *ts_params = &testsuite_params;
3560 static struct rte_cryptodev_sym_session *sess;
3562 if (rte_cryptodev_count() == 0) {
3563 printf("\nNo crypto devices found. Is PMD build configured?\n");
3567 /* Create Crypto session*/
3568 sess = test_perf_create_armv8_session(ts_params->dev_id,
3569 pparams->chain, pparams->cipher_algo,
3570 pparams->cipher_key_length, pparams->auth_algo);
3571 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3573 /* Generate a burst of crypto operations */
3574 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3575 mbufs[i] = test_perf_create_pktmbuf(
3579 if (mbufs[i] == NULL) {
3580 printf("\nFailed to get mbuf - freeing the rest.\n");
3581 for (k = 0; k < i; k++)
3582 rte_pktmbuf_free(mbufs[k]);
3587 tsc_start = rte_rdtsc();
3589 while (total_enqueued < pparams->total_operations) {
3590 if ((total_enqueued + pparams->burst_size) <=
3591 pparams->total_operations)
3592 burst_size = pparams->burst_size;
3594 burst_size = pparams->total_operations - total_enqueued;
3596 ops_needed = burst_size - ops_unused;
3598 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3599 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3600 printf("\nFailed to alloc enough ops, finish dequeuing "
3601 "and free ops below.");
3603 for (i = 0; i < ops_needed; i++)
3604 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3605 mbufs[i + (pparams->burst_size *
3606 (j % NUM_MBUF_SETS))], sess,
3607 pparams->buf_size, digest_length,
3611 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3612 queue_id, ops, burst_size);
3614 if (burst_enqueued < burst_size)
3617 ops_unused = burst_size - burst_enqueued;
3618 total_enqueued += burst_enqueued;
3622 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3623 proc_ops, pparams->burst_size);
3624 if (burst_dequeued == 0)
3627 processed += burst_dequeued;
3629 for (l = 0; l < burst_dequeued; l++)
3630 rte_crypto_op_free(proc_ops[l]);
3635 /* Dequeue any operations still in the crypto device */
3636 while (processed < pparams->total_operations) {
3637 /* Sending 0 length burst to flush sw crypto device */
3638 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3641 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3642 proc_ops, pparams->burst_size);
3643 if (burst_dequeued == 0)
3646 processed += burst_dequeued;
3648 for (m = 0; m < burst_dequeued; m++)
3649 rte_crypto_op_free(proc_ops[m]);
3653 tsc_end = rte_rdtsc();
3655 double ops_s = ((double)processed / (tsc_end - tsc_start))
3657 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3660 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3661 ops_s / 1000000, throughput, retries, failed_polls);
3663 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3664 rte_pktmbuf_free(mbufs[i]);
3667 return TEST_SUCCESS;
3672 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3673 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3674 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3676 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3677 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3678 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3680 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3681 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3682 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3685 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3687 unsigned total_operations = 1000000;
3688 unsigned burst_size = 32;
3689 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3692 struct perf_test_params params_set[] = {
3694 .chain = CIPHER_ONLY,
3695 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3696 .cipher_key_length = 16,
3697 .auth_algo = RTE_CRYPTO_AUTH_NULL
3700 .chain = CIPHER_HASH,
3701 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3702 .cipher_key_length = 16,
3703 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3706 .chain = CIPHER_HASH,
3708 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3709 .cipher_key_length = 16,
3710 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3713 .chain = CIPHER_HASH,
3715 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3716 .cipher_key_length = 16,
3717 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3720 .chain = CIPHER_HASH,
3722 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3723 .cipher_key_length = 32,
3724 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3727 .chain = CIPHER_HASH,
3729 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3730 .cipher_key_length = 32,
3731 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3734 .chain = CIPHER_HASH,
3736 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3737 .cipher_key_length = 32,
3738 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3742 for (i = 0; i < RTE_DIM(params_set); i++) {
3744 params_set[i].total_operations = total_operations;
3745 params_set[i].burst_size = burst_size;
3746 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3747 " burst_size: %d ops\n",
3748 chain_mode_name(params_set[i].chain),
3749 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3750 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3751 params_set[i].cipher_key_length,
3753 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3754 "Retries\tEmptyPolls\n");
3755 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3756 params_set[i].buf_size = buf_lengths[j];
3757 test_perf_aes_sha(testsuite_params.dev_id, 0,
3765 test_perf_snow3G_vary_pkt_size(void)
3767 unsigned total_operations = 1000000;
3770 uint16_t burst_sizes[] = { 64 };
3771 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3773 struct perf_test_params params_set[] = {
3775 .chain = CIPHER_ONLY,
3776 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3777 .cipher_key_length = 16,
3778 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3782 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3783 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3784 .cipher_key_length = 16
3788 printf("\n\nStart %s.", __func__);
3789 printf("\nTest to measure max throughput at various pkt sizes.");
3790 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3791 " so cycle cost not relevant (n/a displayed).");
3793 for (i = 0; i < RTE_DIM(params_set); i++) {
3795 params_set[i].total_operations = total_operations;
3796 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3797 enum rte_crypto_cipher_algorithm cipher_algo =
3798 params_set[i].cipher_algo;
3799 enum rte_crypto_auth_algorithm auth_algo =
3800 params_set[i].auth_algo;
3801 printf("\nOn %s dev%u qp%u, %s, "
3802 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3803 pmd_name(gbl_cryptodev_perftest_devtype),
3804 testsuite_params.dev_id, 0,
3805 chain_mode_name(params_set[i].chain),
3806 rte_crypto_cipher_algorithm_strings[cipher_algo],
3807 rte_crypto_auth_algorithm_strings[auth_algo],
3810 params_set[i].burst_size = burst_sizes[k];
3811 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3812 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3813 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3815 params_set[i].buf_size = buf_lengths[j];
3817 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3826 test_perf_openssl_vary_pkt_size(void)
3828 unsigned int total_operations = 10000;
3829 unsigned int burst_size = { 64 };
3830 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3834 struct perf_test_params params_set[] = {
3836 .chain = CIPHER_HASH,
3838 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3839 .cipher_key_length = 16,
3840 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3843 .chain = CIPHER_HASH,
3845 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3846 .cipher_key_length = 24,
3847 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3850 .chain = CIPHER_HASH,
3852 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3853 .cipher_key_length = 16,
3854 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3857 .chain = CIPHER_HASH,
3859 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3860 .cipher_key_length = 32,
3861 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3864 .chain = CIPHER_HASH,
3866 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3867 .cipher_key_length = 16,
3868 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3871 .chain = CIPHER_HASH,
3873 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3874 .cipher_key_length = 24,
3875 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3878 .chain = CIPHER_HASH,
3880 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3881 .cipher_key_length = 16,
3882 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3886 for (i = 0; i < RTE_DIM(params_set); i++) {
3887 params_set[i].total_operations = total_operations;
3888 params_set[i].burst_size = burst_size;
3889 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3890 " burst_size: %d ops\n",
3891 chain_mode_name(params_set[i].chain),
3892 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3893 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3894 params_set[i].cipher_key_length,
3896 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3898 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3899 params_set[i].buf_size = buf_lengths[j];
3900 test_perf_openssl(testsuite_params.dev_id, 0,
3909 test_perf_openssl_vary_burst_size(void)
3911 unsigned int total_operations = 4096;
3912 uint16_t buf_lengths[] = { 40 };
3915 struct perf_test_params params_set[] = {
3917 .chain = CIPHER_HASH,
3919 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3920 .cipher_key_length = 16,
3921 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3924 .chain = CIPHER_HASH,
3926 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3927 .cipher_key_length = 24,
3928 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3931 .chain = CIPHER_HASH,
3933 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3934 .cipher_key_length = 16,
3935 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3938 .chain = CIPHER_HASH,
3940 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3941 .cipher_key_length = 32,
3942 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3945 .chain = CIPHER_HASH,
3947 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3948 .cipher_key_length = 16,
3949 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3952 .chain = CIPHER_HASH,
3954 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3955 .cipher_key_length = 24,
3956 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3959 .chain = CIPHER_HASH,
3961 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3962 .cipher_key_length = 16,
3963 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3967 printf("\n\nStart %s.", __func__);
3968 printf("\nThis Test measures the average IA cycle cost using a "
3969 "constant request(packet) size. ");
3970 printf("Cycle cost is only valid when indicators show device is not"
3971 " busy, i.e. Retries and EmptyPolls = 0");
3973 for (i = 0; i < RTE_DIM(params_set); i++) {
3975 params_set[i].total_operations = total_operations;
3977 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3978 params_set[i].buf_size = buf_lengths[j];
3979 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3987 test_perf_armv8_vary_pkt_size(void)
3989 unsigned int total_operations = 100000;
3990 unsigned int burst_size = { 64 };
3991 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3995 struct perf_test_params params_set[] = {
3997 .chain = CIPHER_HASH,
3999 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4000 .cipher_key_length = 16,
4001 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4004 .chain = HASH_CIPHER,
4006 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4007 .cipher_key_length = 16,
4008 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4011 .chain = CIPHER_HASH,
4013 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4014 .cipher_key_length = 16,
4015 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4018 .chain = HASH_CIPHER,
4020 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4021 .cipher_key_length = 16,
4022 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4026 for (i = 0; i < RTE_DIM(params_set); i++) {
4027 params_set[i].total_operations = total_operations;
4028 params_set[i].burst_size = burst_size;
4029 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4030 " burst_size: %d ops\n",
4031 chain_mode_name(params_set[i].chain),
4032 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4033 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4034 params_set[i].cipher_key_length,
4036 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4038 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4039 params_set[i].buf_size = buf_lengths[j];
4040 test_perf_armv8(testsuite_params.dev_id, 0,
4049 test_perf_armv8_vary_burst_size(void)
4051 unsigned int total_operations = 4096;
4052 uint16_t buf_lengths[] = { 64 };
4055 struct perf_test_params params_set[] = {
4057 .chain = CIPHER_HASH,
4059 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4060 .cipher_key_length = 16,
4061 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4064 .chain = HASH_CIPHER,
4066 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4067 .cipher_key_length = 16,
4068 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4071 .chain = CIPHER_HASH,
4073 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4074 .cipher_key_length = 16,
4075 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4078 .chain = HASH_CIPHER,
4080 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4081 .cipher_key_length = 16,
4082 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4086 printf("\n\nStart %s.", __func__);
4087 printf("\nThis Test measures the average IA cycle cost using a "
4088 "constant request(packet) size. ");
4089 printf("Cycle cost is only valid when indicators show device is "
4090 "not busy, i.e. Retries and EmptyPolls = 0");
4092 for (i = 0; i < RTE_DIM(params_set); i++) {
4094 params_set[i].total_operations = total_operations;
4096 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4097 params_set[i].buf_size = buf_lengths[j];
4098 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4106 test_perf_aes_cbc_vary_burst_size(void)
4108 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4112 static struct rte_cryptodev_sym_session *
4113 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4115 static struct rte_cryptodev_sym_session *sess;
4116 struct rte_crypto_sym_xform cipher_xform = { 0 };
4117 struct rte_crypto_sym_xform auth_xform = { 0 };
4119 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4120 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4122 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4123 pparams->session_attrs->key_cipher_len);
4124 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4125 pparams->session_attrs->key_auth_len);
4127 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4128 cipher_xform.next = NULL;
4130 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4131 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4132 cipher_xform.cipher.key.data = cipher_key;
4133 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4134 cipher_xform.cipher.iv.length = pparams->session_attrs->iv_len;
4135 cipher_xform.cipher.iv.offset = IV_OFFSET;
4137 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4138 auth_xform.next = NULL;
4140 auth_xform.auth.op = pparams->session_attrs->auth;
4141 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4143 auth_xform.auth.add_auth_data_length = pparams->session_attrs->aad_len;
4144 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4145 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4148 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4149 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4150 cipher_xform.next = &auth_xform;
4151 sess = rte_cryptodev_sym_session_create(dev_id,
4154 auth_xform.next = &cipher_xform;
4155 sess = rte_cryptodev_sym_session_create(dev_id,
4162 static inline struct rte_crypto_op *
4163 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4164 struct rte_cryptodev_sym_session *sess,
4165 struct crypto_params *m_hlp,
4166 struct perf_test_params *params)
4168 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4169 uint8_t *, IV_OFFSET);
4171 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4172 rte_crypto_op_free(op);
4176 op->sym->auth.digest.data = m_hlp->digest;
4177 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4179 params->session_attrs->aad_len +
4180 params->symmetric_op->p_len);
4182 op->sym->auth.digest.length = params->symmetric_op->t_len;
4184 op->sym->auth.aad.data = m_hlp->aad;
4185 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
4187 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4188 params->session_attrs->aad_len);
4190 rte_memcpy(iv_ptr, params->session_attrs->iv_data,
4191 params->session_attrs->iv_len);
4192 if (params->session_attrs->iv_len == 12)
4195 op->sym->auth.data.offset =
4196 params->session_attrs->aad_len;
4197 op->sym->auth.data.length = params->symmetric_op->p_len;
4199 op->sym->cipher.data.offset =
4200 params->session_attrs->aad_len;
4201 op->sym->cipher.data.length = params->symmetric_op->p_len;
4208 static struct rte_mbuf *
4209 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4210 struct perf_test_params *params,
4211 unsigned buf_sz, struct crypto_params *m_hlp)
4213 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4214 uint16_t aad_len = params->session_attrs->aad_len;
4215 uint16_t digest_size = params->symmetric_op->t_len;
4218 p = rte_pktmbuf_append(m, aad_len);
4220 rte_pktmbuf_free(m);
4223 m_hlp->aad = (uint8_t *)p;
4225 p = rte_pktmbuf_append(m, buf_sz);
4227 rte_pktmbuf_free(m);
4230 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4232 p = rte_pktmbuf_append(m, digest_size);
4234 rte_pktmbuf_free(m);
4237 m_hlp->digest = (uint8_t *)p;
4243 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4244 struct perf_test_params *pparams, uint32_t test_ops)
4247 struct crypto_testsuite_params *ts_params = &testsuite_params;
4248 struct rte_cryptodev_sym_session *sess;
4249 struct rte_crypto_op *ops[pparams->burst_size];
4250 struct rte_crypto_op *proc_ops[pparams->burst_size];
4251 uint32_t total_operations = pparams->total_operations;
4253 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4254 uint64_t processed = 0, failed_polls = 0, retries = 0;
4255 uint64_t tsc_start = 0, tsc_end = 0;
4257 uint16_t i = 0, l = 0, m = 0;
4258 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4259 uint16_t ops_unused = 0;
4261 struct rte_mbuf *mbufs[burst];
4262 struct crypto_params m_hlp[burst];
4264 if (rte_cryptodev_count() == 0) {
4265 printf("\nNo crypto devices available. "
4266 "Is kernel driver loaded?\n");
4270 sess = test_perf_create_session(dev_id, pparams);
4271 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4273 for (i = 0; i < burst; i++) {
4274 mbufs[i] = test_perf_create_pktmbuf_fill(
4276 pparams, pparams->symmetric_op->p_len,
4281 total_operations = test_ops;
4283 tsc_start = rte_rdtsc_precise();
4284 while (total_enqueued < total_operations) {
4285 uint16_t burst_size =
4286 total_enqueued+pparams->burst_size <= total_operations ?
4287 pparams->burst_size : total_operations-total_enqueued;
4288 uint16_t ops_needed = burst_size-ops_unused;
4290 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4291 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4292 printf("\nFailed to alloc enough ops, "
4293 "finish dequeuing");
4295 for (i = 0; i < ops_needed; i++)
4296 ops[i] = perf_gcm_set_crypto_op(ops[i],
4297 mbufs[i + (pparams->burst_size *
4298 (j % NUM_MBUF_SETS))],
4299 sess, &m_hlp[i + (pparams->burst_size *
4300 (j % NUM_MBUF_SETS))], pparams);
4303 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4304 queue_id, ops, burst_size);
4306 if (burst_enqueued < burst_size)
4309 ops_unused = burst_size-burst_enqueued;
4310 total_enqueued += burst_enqueued;
4314 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4315 proc_ops, pparams->burst_size);
4316 if (burst_dequeued == 0)
4319 processed += burst_dequeued;
4321 for (l = 0; l < burst_dequeued; l++)
4322 rte_crypto_op_free(proc_ops[l]);
4328 /* Dequeue any operations still in the crypto device */
4329 while (processed < total_operations) {
4330 /* Sending 0 length burst to flush sw crypto device */
4331 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4334 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4335 proc_ops, pparams->burst_size);
4336 if (burst_dequeued == 0)
4339 processed += burst_dequeued;
4341 for (m = 0; m < burst_dequeued; m++) {
4343 uint8_t *pkt = rte_pktmbuf_mtod(
4344 proc_ops[m]->sym->m_src,
4347 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4348 pparams->symmetric_op->c_data,
4350 pparams->session_attrs->aad_len,
4351 pparams->symmetric_op->c_len,
4352 "GCM Ciphertext data not as expected");
4354 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4355 pparams->symmetric_op->t_data,
4357 pparams->session_attrs->aad_len +
4358 pparams->symmetric_op->c_len,
4359 pparams->symmetric_op->t_len,
4360 "GCM MAC data not as expected");
4363 rte_crypto_op_free(proc_ops[m]);
4368 tsc_end = rte_rdtsc_precise();
4370 double ops_s = ((double)processed / (tsc_end - tsc_start))
4372 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4376 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4377 pparams->symmetric_op->p_len,
4378 ops_s/1000000, throughput, retries, failed_polls);
4381 for (i = 0; i < burst; i++)
4382 rte_pktmbuf_free(mbufs[i]);
4383 rte_cryptodev_sym_session_free(dev_id, sess);
4389 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4391 uint16_t i, j, k, loops = 1;
4393 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4395 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4396 &AES_GCM_128_12IV_0AAD
4399 if (continual_buf_len)
4400 loops = continual_size;
4402 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4404 const unsigned burst_size = 32;
4406 struct symmetric_op ops_set[TEST_CASES_GCM];
4407 struct perf_test_params params_set[TEST_CASES_GCM];
4408 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4409 static const struct cryptodev_perf_test_data *gcm_test;
4411 for (i = 0; i < TEST_CASES_GCM; ++i) {
4413 gcm_test = gcm_tests[i];
4415 session_attrs[i].cipher =
4416 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4417 session_attrs[i].cipher_algorithm =
4418 RTE_CRYPTO_CIPHER_AES_GCM;
4419 session_attrs[i].key_cipher_data =
4421 session_attrs[i].key_cipher_len =
4423 session_attrs[i].auth_algorithm =
4424 RTE_CRYPTO_AUTH_AES_GCM;
4425 session_attrs[i].auth =
4426 RTE_CRYPTO_AUTH_OP_GENERATE;
4427 session_attrs[i].key_auth_data = NULL;
4428 session_attrs[i].key_auth_len = 0;
4429 session_attrs[i].aad_len = gcm_test->aad.len;
4430 session_attrs[i].digest_len =
4431 gcm_test->auth_tag.len;
4432 session_attrs[i].iv_len = gcm_test->iv.len;
4433 session_attrs[i].iv_data = gcm_test->iv.data;
4435 ops_set[i].aad_data = gcm_test->aad.data;
4436 ops_set[i].p_data = gcm_test->plaintext.data;
4437 ops_set[i].p_len = buf_lengths[i];
4438 ops_set[i].c_data = gcm_test->ciphertext.data;
4439 ops_set[i].c_len = buf_lengths[i];
4440 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4441 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4443 params_set[i].chain = CIPHER_HASH;
4444 params_set[i].session_attrs = &session_attrs[i];
4445 params_set[i].symmetric_op = &ops_set[i];
4446 if (continual_buf_len)
4447 params_set[i].total_operations = 0xFFFFFF;
4449 params_set[i].total_operations = 1000000;
4451 params_set[i].burst_size = burst_size;
4455 if (continual_buf_len)
4456 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4457 " burst size: %u", "AES_GCM", "AES_GCM",
4458 gcm_test->key.len << 3, burst_size);
4460 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4462 if (!continual_buf_len) {
4463 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4464 " burst size: %u", "AES_GCM", "AES_GCM",
4465 gcm_test->key.len << 3, burst_size);
4466 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4467 " Retries\tEmptyPolls");
4470 uint16_t len = RTE_DIM(buf_lengths);
4473 if (continual_buf_len) {
4474 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4475 if (buf_lengths[k] == continual_buf_len) {
4481 for (j = p; j < len; ++j) {
4483 params_set[i].symmetric_op->c_len = buf_lengths[j];
4484 params_set[i].symmetric_op->p_len = buf_lengths[j];
4486 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4487 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4489 /* Run is twice, one for encryption/hash checks,
4492 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4496 for (k = 0; k < loops; k++) {
4497 if (continual_buf_len)
4498 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4499 "Throughput(Gbps)\t"
4500 "Retries\tEmptyPolls");
4501 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4504 if (continual_buf_len)
4505 printf("\n\nCompleted loop %i of %i ...",
4515 static int test_cryptodev_perf_AES_GCM(void)
4517 return test_perf_AES_GCM(0, 0);
4520 * This function calls AES GCM performance tests providing
4521 * size of packet as an argument. If size of packet is not
4522 * in the buf_lengths array, all sizes will be used
4524 static int test_continual_perf_AES_GCM(void)
4526 return test_perf_AES_GCM(1024, 10);
4530 test_perf_continual_performance_test(void)
4532 unsigned int total_operations = 0xFFFFFF;
4533 unsigned int total_loops = 10;
4534 unsigned int burst_size = 32;
4537 struct perf_test_params params_set = {
4538 .total_operations = total_operations,
4539 .burst_size = burst_size,
4542 .chain = CIPHER_HASH,
4544 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4545 .cipher_key_length = 16,
4546 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4549 for (i = 1; i <= total_loops; ++i) {
4550 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4551 " burst_size: %d ops\n",
4552 chain_mode_name(params_set.chain),
4553 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4554 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4555 params_set.cipher_key_length,
4557 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4558 "Retries\tEmptyPolls\n");
4559 test_perf_aes_sha(testsuite_params.dev_id, 0,
4561 printf("\nCompleted loop %i of %i ...", i, total_loops);
4566 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4567 .suite_name = "Crypto Device Continual Performance Test",
4568 .setup = testsuite_setup,
4569 .teardown = testsuite_teardown,
4570 .unit_test_cases = {
4571 TEST_CASE_ST(ut_setup, ut_teardown,
4572 test_perf_continual_performance_test),
4573 TEST_CASE_ST(ut_setup, ut_teardown,
4574 test_continual_perf_AES_GCM),
4575 TEST_CASES_END() /**< NULL terminate unit test array */
4579 static struct unit_test_suite cryptodev_testsuite = {
4580 .suite_name = "Crypto Device Unit Test Suite",
4581 .setup = testsuite_setup,
4582 .teardown = testsuite_teardown,
4583 .unit_test_cases = {
4584 TEST_CASE_ST(ut_setup, ut_teardown,
4585 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4586 TEST_CASE_ST(ut_setup, ut_teardown,
4587 test_cryptodev_perf_AES_GCM),
4588 TEST_CASE_ST(ut_setup, ut_teardown,
4589 test_perf_aes_cbc_vary_burst_size),
4590 TEST_CASES_END() /**< NULL terminate unit test array */
4594 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4595 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4596 .setup = testsuite_setup,
4597 .teardown = testsuite_teardown,
4598 .unit_test_cases = {
4599 TEST_CASE_ST(ut_setup, ut_teardown,
4600 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4601 TEST_CASES_END() /**< NULL terminate unit test array */
4605 static struct unit_test_suite cryptodev_gcm_testsuite = {
4606 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4607 .setup = testsuite_setup,
4608 .teardown = testsuite_teardown,
4609 .unit_test_cases = {
4610 TEST_CASE_ST(ut_setup, ut_teardown,
4611 test_cryptodev_perf_AES_GCM),
4612 TEST_CASES_END() /**< NULL terminate unit test array */
4616 static struct unit_test_suite cryptodev_aes_testsuite = {
4617 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4618 .setup = testsuite_setup,
4619 .teardown = testsuite_teardown,
4620 .unit_test_cases = {
4621 TEST_CASE_ST(ut_setup, ut_teardown,
4622 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4623 TEST_CASES_END() /**< NULL terminate unit test array */
4627 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4628 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4629 .setup = testsuite_setup,
4630 .teardown = testsuite_teardown,
4631 .unit_test_cases = {
4632 TEST_CASE_ST(ut_setup, ut_teardown,
4633 test_perf_snow3G_vary_pkt_size),
4634 TEST_CASE_ST(ut_setup, ut_teardown,
4635 test_perf_snow3G_vary_burst_size),
4636 TEST_CASES_END() /**< NULL terminate unit test array */
4640 static struct unit_test_suite cryptodev_openssl_testsuite = {
4641 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4642 .setup = testsuite_setup,
4643 .teardown = testsuite_teardown,
4644 .unit_test_cases = {
4645 TEST_CASE_ST(ut_setup, ut_teardown,
4646 test_perf_openssl_vary_pkt_size),
4647 TEST_CASE_ST(ut_setup, ut_teardown,
4648 test_perf_openssl_vary_burst_size),
4649 TEST_CASES_END() /**< NULL terminate unit test array */
4653 static struct unit_test_suite cryptodev_armv8_testsuite = {
4654 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4655 .setup = testsuite_setup,
4656 .teardown = testsuite_teardown,
4657 .unit_test_cases = {
4658 TEST_CASE_ST(ut_setup, ut_teardown,
4659 test_perf_armv8_vary_pkt_size),
4660 TEST_CASE_ST(ut_setup, ut_teardown,
4661 test_perf_armv8_vary_burst_size),
4662 TEST_CASES_END() /**< NULL terminate unit test array */
4667 perftest_aesni_gcm_cryptodev(void)
4669 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4671 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4675 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4677 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4679 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4683 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4685 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4687 return unit_test_suite_runner(&cryptodev_testsuite);
4691 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4693 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4695 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4699 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4701 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4703 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4707 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4709 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4711 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4715 perftest_qat_continual_cryptodev(void)
4717 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4719 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4723 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4725 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4727 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4731 perftest_dpaa2_sec_cryptodev(void)
4733 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4735 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4738 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4739 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4740 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4741 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4742 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4743 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4744 perftest_openssl_cryptodev);
4745 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4746 perftest_qat_continual_cryptodev);
4747 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4748 perftest_sw_armv8_cryptodev);
4749 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4750 perftest_dpaa2_sec_cryptodev);