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"
47 #define PERF_NUM_OPS_INFLIGHT (128)
48 #define DEFAULT_NUM_REQS_TO_SUBMIT (10000000)
50 struct crypto_testsuite_params {
51 struct rte_mempool *mbuf_mp;
52 struct rte_mempool *op_mpool;
54 uint16_t nb_queue_pairs;
56 struct rte_cryptodev_config conf;
57 struct rte_cryptodev_qp_conf qp_conf;
70 const uint8_t *iv_data;
73 const uint8_t *aad_data;
76 const uint8_t *p_data;
79 const uint8_t *c_data;
82 const uint8_t *t_data;
87 struct symmetric_session_attrs {
88 enum rte_crypto_cipher_operation cipher;
89 enum rte_crypto_auth_operation auth;
91 enum rte_crypto_cipher_algorithm cipher_algorithm;
92 const uint8_t *key_cipher_data;
93 uint32_t key_cipher_len;
95 enum rte_crypto_auth_algorithm auth_algorithm;
96 const uint8_t *key_auth_data;
97 uint32_t key_auth_len;
102 #define ALIGN_POW2_ROUNDUP(num, align) \
103 (((num) + (align) - 1) & ~((align) - 1))
106 * This struct is needed to avoid unnecessary allocation or checking
107 * of allocation of crypto params with current alloc on the fly
111 struct crypto_params {
116 struct perf_test_params {
118 unsigned total_operations;
122 enum chain_mode chain;
124 enum rte_crypto_cipher_algorithm cipher_algo;
125 unsigned cipher_key_length;
126 enum rte_crypto_auth_algorithm auth_algo;
128 struct symmetric_session_attrs *session_attrs;
130 struct symmetric_op *symmetric_op;
133 #define MAX_NUM_OF_OPS_PER_UT (128)
135 struct crypto_unittest_params {
136 struct rte_crypto_sym_xform cipher_xform;
137 struct rte_crypto_sym_xform auth_xform;
139 struct rte_cryptodev_sym_session *sess;
141 struct rte_crypto_op *op;
143 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
144 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
149 static struct rte_cryptodev_sym_session *
150 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
151 enum rte_crypto_cipher_algorithm cipher_algo,
152 unsigned int cipher_key_len,
153 enum rte_crypto_auth_algorithm auth_algo);
154 static struct rte_cryptodev_sym_session *
155 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
156 enum rte_crypto_cipher_algorithm cipher_algo,
157 unsigned int cipher_key_len,
158 enum rte_crypto_auth_algorithm auth_algo);
159 static struct rte_cryptodev_sym_session *
160 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
161 enum rte_crypto_cipher_algorithm cipher_algo,
162 unsigned int cipher_key_len,
163 enum rte_crypto_auth_algorithm auth_algo);
165 static struct rte_mbuf *
166 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
167 static inline struct rte_crypto_op *
168 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
169 struct rte_cryptodev_sym_session *sess, unsigned data_len,
170 unsigned digest_len);
171 static inline struct rte_crypto_op *
172 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
173 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
174 unsigned int digest_len, enum chain_mode chain);
175 static inline struct rte_crypto_op *
176 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
177 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
178 unsigned int digest_len, enum chain_mode chain __rte_unused);
179 static inline struct rte_crypto_op *
180 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
181 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
182 unsigned int digest_len, enum chain_mode chain __rte_unused);
183 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
186 static const char *chain_mode_name(enum chain_mode mode)
189 case CIPHER_HASH: return "cipher_hash"; break;
190 case HASH_CIPHER: return "hash_cipher"; break;
191 case CIPHER_ONLY: return "cipher_only"; break;
192 case HASH_ONLY: return "hash_only"; break;
193 default: return ""; break;
197 static const char *pmd_name(enum rte_cryptodev_type pmd)
200 case RTE_CRYPTODEV_NULL_PMD: return RTE_STR(CRYPTODEV_NAME_NULL_PMD); break;
201 case RTE_CRYPTODEV_AESNI_GCM_PMD:
202 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
203 case RTE_CRYPTODEV_AESNI_MB_PMD:
204 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
205 case RTE_CRYPTODEV_QAT_SYM_PMD:
206 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
207 case RTE_CRYPTODEV_SNOW3G_PMD:
208 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
209 case RTE_CRYPTODEV_DPAA2_SEC_PMD:
210 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
216 static struct rte_mbuf *
217 setup_test_string(struct rte_mempool *mpool,
218 const uint8_t *data, size_t len, uint8_t blocksize)
220 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
221 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
224 char *dst = rte_pktmbuf_append(m, t_len);
231 rte_memcpy(dst, (const void *)data, t_len);
236 static struct crypto_testsuite_params testsuite_params = { NULL };
237 static struct crypto_unittest_params unittest_params;
238 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
241 testsuite_setup(void)
243 struct crypto_testsuite_params *ts_params = &testsuite_params;
244 struct rte_cryptodev_info info;
245 unsigned i, nb_devs, valid_dev_id = 0;
249 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
250 if (ts_params->mbuf_mp == NULL) {
251 /* Not already created so create */
252 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
253 "CRYPTO_PERF_MBUFPOOL",
254 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
256 if (ts_params->mbuf_mp == NULL) {
257 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
263 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
264 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
265 NUM_MBUFS, MBUF_CACHE_SIZE,
267 sizeof(struct rte_crypto_sym_xform) +
270 if (ts_params->op_mpool == NULL) {
271 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
275 /* Create an AESNI MB device if required */
276 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_MB_PMD) {
277 #ifndef RTE_LIBRTE_PMD_AESNI_MB
278 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
279 " enabled in config file to run this testsuite.\n");
282 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD);
285 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
287 TEST_ASSERT(ret == 0,
288 "Failed to create instance of pmd : %s",
289 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
293 /* Create an AESNI GCM device if required */
294 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_GCM_PMD) {
295 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
296 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
297 " enabled in config file to run this testsuite.\n");
300 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD);
303 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
305 TEST_ASSERT(ret == 0,
306 "Failed to create instance of pmd : %s",
307 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
311 /* Create a SNOW3G device if required */
312 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_SNOW3G_PMD) {
313 #ifndef RTE_LIBRTE_PMD_SNOW3G
314 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
315 " enabled in config file to run this testsuite.\n");
318 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
321 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
323 TEST_ASSERT(ret == 0,
324 "Failed to create instance of pmd : %s",
325 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
329 /* Create an OPENSSL device if required */
330 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_OPENSSL_PMD) {
331 #ifndef RTE_LIBRTE_PMD_OPENSSL
332 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
333 " enabled in config file to run this testsuite.\n");
336 nb_devs = rte_cryptodev_count_devtype(
337 RTE_CRYPTODEV_OPENSSL_PMD);
340 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
343 TEST_ASSERT(ret == 0, "Failed to create "
344 "instance of pmd : %s",
345 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
349 /* Create an ARMv8 device if required */
350 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_ARMV8_PMD) {
351 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
352 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
353 " enabled in config file to run this testsuite.\n");
356 nb_devs = rte_cryptodev_count_devtype(
357 RTE_CRYPTODEV_ARMV8_PMD);
360 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
363 TEST_ASSERT(ret == 0, "Failed to create "
364 "instance of pmd : %s",
365 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
369 #ifndef RTE_LIBRTE_PMD_QAT
370 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
371 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
372 "in config file to run this testsuite.\n");
377 nb_devs = rte_cryptodev_count();
379 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
383 /* Search for the first valid */
384 for (i = 0; i < nb_devs; i++) {
385 rte_cryptodev_info_get(i, &info);
386 if (info.dev_type == gbl_cryptodev_perftest_devtype) {
387 ts_params->dev_id = i;
397 * Using Crypto Device Id 0 by default.
398 * Set up all the qps on this device
401 rte_cryptodev_info_get(ts_params->dev_id, &info);
403 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
404 ts_params->conf.socket_id = SOCKET_ID_ANY;
405 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
407 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
409 "Failed to configure cryptodev %u",
412 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
413 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
415 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
416 ts_params->dev_id, qp_id,
418 rte_cryptodev_socket_id(ts_params->dev_id)),
419 "Failed to setup queue pair %u on cryptodev %u",
420 qp_id, ts_params->dev_id);
426 testsuite_teardown(void)
428 struct crypto_testsuite_params *ts_params =
431 if (ts_params->mbuf_mp != NULL)
432 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
433 rte_mempool_avail_count(ts_params->mbuf_mp));
434 if (ts_params->op_mpool != NULL)
435 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
436 rte_mempool_avail_count(ts_params->op_mpool));
442 struct crypto_testsuite_params *ts_params = &testsuite_params;
443 struct crypto_unittest_params *ut_params = &unittest_params;
445 /* Clear unit test parameters before running test */
446 memset(ut_params, 0, sizeof(*ut_params));
448 rte_cryptodev_stats_reset(ts_params->dev_id);
450 /* Start the device */
451 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
452 "Failed to start cryptodev %u",
461 struct crypto_testsuite_params *ts_params = &testsuite_params;
462 struct crypto_unittest_params *ut_params = &unittest_params;
463 struct rte_cryptodev_stats stats;
467 /* free crypto session structure */
469 rte_cryptodev_sym_session_free(ts_params->dev_id,
472 /* free crypto operation structure */
474 rte_crypto_op_free(ut_params->op);
476 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
477 if (ut_params->obuf[i])
478 rte_pktmbuf_free(ut_params->obuf[i]);
479 else if (ut_params->ibuf[i])
480 rte_pktmbuf_free(ut_params->ibuf[i]);
483 if (ts_params->mbuf_mp != NULL)
484 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
485 rte_mempool_avail_count(ts_params->mbuf_mp));
487 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
489 /* Stop the device */
490 rte_cryptodev_stop(ts_params->dev_id);
493 const char plaintext_quote[] =
494 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
495 "Marseilles--The Arrival. On the 24th of February, 1815, the "
496 "look-out at Notre-Dame de la Garde signalled the three-master,"
497 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
498 "pilot put off immediately, and rounding the Chateau d'If, got "
499 "on board the vessel between Cape Morgion and Rion island. "
500 "Immediately, and according to custom, the ramparts of Fort "
501 "Saint-Jean were covered with spectators; it is always an event "
502 "at Marseilles for a ship to come into port, especially when "
503 "this ship, like the Pharaon, has been built, rigged, and laden"
504 " at the old Phocee docks, and belongs to an owner of the city."
505 " The ship drew on and had safely passed the strait, which some"
506 " volcanic shock has made between the Calasareigne and Jaros "
507 "islands; had doubled Pomegue, and approached the harbor under"
508 " topsails, jib, and spanker, but so slowly and sedately that"
509 " the idlers, with that instinct which is the forerunner of "
510 "evil, asked one another what misfortune could have happened "
511 "on board. However, those experienced in navigation saw plainly"
512 " that if any accident had occurred, it was not to the vessel "
513 "herself, for she bore down with all the evidence of being "
514 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
515 "already eased off, and standing by the side of the pilot, who"
516 " was steering the Pharaon towards the narrow entrance of the"
517 " inner port, was a young man, who, with activity and vigilant"
518 " eye, watched every motion of the ship, and repeated each "
519 "direction of the pilot. The vague disquietude which prevailed "
520 "among the spectators had so much affected one of the crowd "
521 "that he did not await the arrival of the vessel in harbor, but"
522 " jumping into a small skiff, desired to be pulled alongside "
523 "the Pharaon, which he reached as she rounded into La Reserve "
524 "basin. When the young man on board saw this person approach, "
525 "he left his station by the pilot, and, hat in hand, leaned "
526 "over the ship's bulwarks. He was a fine, tall, slim young "
527 "fellow of eighteen or twenty, with black eyes, and hair as "
528 "dark as a raven's wing; and his whole appearance bespoke that "
529 "calmness and resolution peculiar to men accustomed from their "
530 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
531 "cried the man in the skiff. \"What's the matter? and why have "
532 "you such an air of sadness aboard?\" \"A great misfortune, M. "
533 "Morrel,\" replied the young man,--\"a great misfortune, for me"
534 " especially! Off Civita Vecchia we lost our brave Captain "
535 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
536 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
537 " that head. But poor Captain Leclere--\" \"What happened to "
538 "him?\" asked the owner, with an air of considerable "
539 "resignation. \"What happened to the worthy captain?\" \"He "
540 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
541 "brain-fever in dreadful agony.\" Then turning to the crew, "
542 "he said, \"Bear a hand there, to take in sail!\" All hands "
543 "obeyed, and at once the eight or ten seamen who composed the "
544 "crew, sprang to their respective stations at the spanker "
545 "brails and outhaul, topsail sheets and halyards, the jib "
546 "downhaul, and the topsail clewlines and buntlines. The young "
547 "sailor gave a look to see that his orders were promptly and "
548 "accurately obeyed, and then turned again to the owner. \"And "
549 "how did this misfortune occur?\" inquired the latter, resuming"
550 " the interrupted conversation. \"Alas, sir, in the most "
551 "unexpected manner. After a long talk with the harbor-master, "
552 "Captain Leclere left Naples greatly disturbed in mind. In "
553 "twenty-four hours he was attacked by a fever, and died three "
554 "days afterwards. We performed the usual burial service, and he"
555 " is at his rest, sewn up in his hammock with a thirty-six "
556 "pound shot at his head and his heels, off El Giglio island. "
557 "We bring to his widow his sword and cross of honor. It was "
558 "worth while, truly,\" added the young man with a melancholy "
559 "smile, \"to make war against the English for ten years, and "
560 "to die in his bed at last, like everybody else.";
562 #define QUOTE_LEN_64B (64)
563 #define QUOTE_LEN_128B (128)
564 #define QUOTE_LEN_256B (256)
565 #define QUOTE_LEN_512B (512)
566 #define QUOTE_LEN_768B (768)
567 #define QUOTE_LEN_1024B (1024)
568 #define QUOTE_LEN_1280B (1280)
569 #define QUOTE_LEN_1536B (1536)
570 #define QUOTE_LEN_1792B (1792)
571 #define QUOTE_LEN_2048B (2048)
574 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
576 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
578 #define CIPHER_KEY_LENGTH_AES_CBC (16)
579 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
581 static uint8_t aes_cbc_128_key[] = {
582 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
583 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
585 static uint8_t aes_cbc_128_iv[] = {
586 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
587 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
589 static uint8_t hmac_sha256_key[] = {
590 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
591 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
592 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
593 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
596 /* Cipher text output */
598 static const uint8_t AES_CBC_ciphertext_64B[] = {
599 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
600 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
601 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
602 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
603 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
604 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
605 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
606 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
609 static const uint8_t AES_CBC_ciphertext_128B[] = {
610 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
611 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
612 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
613 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
614 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
615 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
616 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
617 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
618 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
619 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
620 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
621 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
622 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
623 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
624 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
625 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
628 static const uint8_t AES_CBC_ciphertext_256B[] = {
629 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
630 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
631 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
632 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
633 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
634 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
635 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
636 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
637 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
638 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
639 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
640 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
641 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
642 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
643 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
644 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
645 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
646 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
647 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
648 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
649 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
650 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
651 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
652 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
653 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
654 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
655 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
656 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
657 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
658 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
659 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
660 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
663 static const uint8_t AES_CBC_ciphertext_512B[] = {
664 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
665 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
666 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
667 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
668 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
669 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
670 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
671 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
672 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
673 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
674 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
675 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
676 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
677 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
678 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
679 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
680 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
681 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
682 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
683 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
684 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
685 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
686 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
687 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
688 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
689 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
690 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
691 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
692 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
693 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
694 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
695 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
696 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
697 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
698 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
699 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
700 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
701 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
702 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
703 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
704 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
705 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
706 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
707 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
708 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
709 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
710 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
711 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
712 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
713 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
714 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
715 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
716 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
717 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
718 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
719 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
720 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
721 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
722 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
723 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
724 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
725 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
726 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
727 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
730 static const uint8_t AES_CBC_ciphertext_768B[] = {
731 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
732 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
733 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
734 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
735 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
736 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
737 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
738 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
739 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
740 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
741 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
742 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
743 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
744 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
745 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
746 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
747 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
748 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
749 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
750 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
751 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
752 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
753 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
754 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
755 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
756 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
757 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
758 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
759 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
760 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
761 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
762 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
763 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
764 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
765 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
766 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
767 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
768 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
769 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
770 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
771 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
772 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
773 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
774 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
775 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
776 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
777 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
778 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
779 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
780 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
781 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
782 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
783 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
784 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
785 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
786 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
787 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
788 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
789 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
790 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
791 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
792 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
793 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
794 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
795 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
796 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
797 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
798 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
799 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
800 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
801 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
802 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
803 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
804 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
805 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
806 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
807 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
808 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
809 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
810 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
811 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
812 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
813 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
814 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
815 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
816 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
817 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
818 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
819 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
820 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
821 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
822 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
823 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
824 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
825 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
826 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
829 static const uint8_t AES_CBC_ciphertext_1024B[] = {
830 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
831 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
832 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
833 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
834 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
835 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
836 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
837 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
838 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
839 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
840 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
841 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
842 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
843 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
844 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
845 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
846 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
847 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
848 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
849 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
850 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
851 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
852 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
853 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
854 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
855 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
856 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
857 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
858 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
859 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
860 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
861 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
862 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
863 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
864 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
865 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
866 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
867 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
868 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
869 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
870 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
871 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
872 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
873 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
874 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
875 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
876 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
877 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
878 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
879 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
880 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
881 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
882 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
883 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
884 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
885 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
886 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
887 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
888 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
889 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
890 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
891 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
892 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
893 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
894 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
895 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
896 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
897 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
898 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
899 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
900 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
901 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
902 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
903 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
904 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
905 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
906 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
907 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
908 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
909 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
910 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
911 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
912 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
913 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
914 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
915 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
916 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
917 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
918 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
919 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
920 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
921 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
922 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
923 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
924 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
925 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
926 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
927 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
928 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
929 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
930 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
931 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
932 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
933 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
934 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
935 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
936 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
937 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
938 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
939 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
940 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
941 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
942 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
943 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
944 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
945 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
946 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
947 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
948 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
949 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
950 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
951 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
952 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
953 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
954 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
955 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
956 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
957 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
960 static const uint8_t AES_CBC_ciphertext_1280B[] = {
961 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
962 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
963 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
964 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
965 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
966 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
967 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
968 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
969 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
970 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
971 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
972 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
973 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
974 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
975 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
976 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
977 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
978 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
979 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
980 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
981 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
982 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
983 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
984 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
985 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
986 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
987 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
988 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
989 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
990 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
991 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
992 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
993 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
994 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
995 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
996 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
997 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
998 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
999 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1000 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1001 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1002 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1003 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1004 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1005 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1006 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1007 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1008 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1009 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1010 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1011 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1012 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1013 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1014 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1015 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1016 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1017 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1018 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1019 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1020 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1021 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1022 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1023 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1024 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1025 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1026 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1027 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1028 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1029 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1030 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1031 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1032 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1033 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1034 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1035 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1036 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1037 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1038 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1039 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1040 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1041 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1042 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1043 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1044 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1045 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1046 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1047 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1048 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1049 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1050 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1051 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1052 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1053 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1054 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1055 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1056 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1057 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1058 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1059 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1060 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1061 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1062 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1063 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1064 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1065 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1066 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1067 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1068 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1069 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1070 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1071 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1072 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1073 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1074 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1075 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1076 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1077 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1078 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1079 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1080 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1081 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1082 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1083 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1084 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1085 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1086 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1087 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1088 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1089 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1090 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1091 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1092 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1093 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1094 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1095 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1096 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1097 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1098 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1099 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1100 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1101 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1102 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1103 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1104 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1105 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1106 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1107 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1108 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1109 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1110 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1111 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1112 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1113 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1114 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1115 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1116 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1117 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1118 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1119 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1120 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1123 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1124 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1125 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1126 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1127 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1128 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1129 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1130 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1131 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1132 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1133 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1134 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1135 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1136 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1137 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1138 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1139 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1140 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1141 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1142 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1143 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1144 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1145 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1146 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1147 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1148 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1149 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1150 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1151 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1152 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1153 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1154 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1155 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1156 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1157 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1158 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1159 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1160 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1161 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1162 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1163 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1164 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1165 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1166 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1167 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1168 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1169 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1170 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1171 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1172 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1173 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1174 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1175 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1176 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1177 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1178 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1179 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1180 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1181 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1182 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1183 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1184 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1185 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1186 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1187 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1188 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1189 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1190 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1191 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1192 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1193 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1194 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1195 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1196 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1197 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1198 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1199 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1200 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1201 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1202 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1203 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1204 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1205 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1206 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1207 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1208 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1209 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1210 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1211 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1212 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1213 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1214 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1215 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1216 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1217 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1218 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1219 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1220 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1221 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1222 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1223 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1224 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1225 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1226 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1227 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1228 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1229 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1230 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1231 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1232 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1233 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1234 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1235 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1236 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1237 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1238 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1239 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1240 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1241 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1242 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1243 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1244 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1245 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1246 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1247 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1248 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1249 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1250 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1251 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1252 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1253 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1254 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1255 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1256 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1257 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1258 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1259 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1260 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1261 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1262 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1263 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1264 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1265 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1266 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1267 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1268 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1269 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1270 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1271 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1272 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1273 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1274 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1275 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1276 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1277 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1278 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1279 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1280 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1281 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1282 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1283 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1284 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1285 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1286 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1287 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1288 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1289 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1290 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1291 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1292 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1293 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1294 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1295 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1296 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1297 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1298 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1299 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1300 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1301 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1302 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1303 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1304 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1305 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1306 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1307 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1308 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1309 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1310 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1311 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1312 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1313 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1314 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1315 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1318 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1319 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1320 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1321 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1322 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1323 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1324 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1325 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1326 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1327 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1328 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1329 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1330 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1331 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1332 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1333 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1334 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1335 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1336 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1337 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1338 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1339 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1340 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1341 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1342 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1343 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1344 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1345 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1346 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1347 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1348 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1349 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1350 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1351 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1352 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1353 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1354 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1355 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1356 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1357 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1358 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1359 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1360 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1361 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1362 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1363 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1364 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1365 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1366 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1367 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1368 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1369 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1370 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1371 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1372 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1373 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1374 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1375 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1376 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1377 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1378 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1379 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1380 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1381 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1382 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1383 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1384 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1385 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1386 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1387 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1388 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1389 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1390 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1391 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1392 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1393 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1394 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1395 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1396 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1397 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1398 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1399 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1400 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1401 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1402 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1403 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1404 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1405 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1406 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1407 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1408 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1409 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1410 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1411 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1412 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1413 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1414 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1415 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1416 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1417 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1418 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1419 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1420 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1421 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1422 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1423 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1424 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1425 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1426 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1427 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1428 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1429 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1430 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1431 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1432 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1433 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1434 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1435 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1436 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1437 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1438 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1439 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1440 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1441 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1442 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1443 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1444 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1445 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1446 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1447 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1448 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1449 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1450 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1451 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1452 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1453 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1454 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1455 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1456 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1457 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1458 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1459 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1460 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1461 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1462 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1463 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1464 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1465 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1466 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1467 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1468 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1469 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1470 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1471 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1472 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1473 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1474 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1475 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1476 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1477 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1478 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1479 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1480 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1481 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1482 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1483 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1484 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1485 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1486 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1487 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1488 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1489 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1490 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1491 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1492 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1493 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1494 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1495 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1496 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1497 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1498 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1499 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1500 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1501 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1502 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1503 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1504 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1505 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1506 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1507 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1508 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1509 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1510 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1511 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1512 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1513 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1514 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1515 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1516 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1517 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1518 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1519 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1520 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1521 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1522 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1523 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1524 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1525 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1526 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1527 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1528 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1529 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1530 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1531 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1532 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1533 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1534 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1535 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1536 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1537 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1538 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1539 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1540 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1541 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1542 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1545 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1546 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1547 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1548 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1549 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1550 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1551 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1552 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1553 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1554 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1555 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1556 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1557 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1558 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1559 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1560 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1561 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1562 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1563 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1564 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1565 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1566 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1567 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1568 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1569 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1570 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1571 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1572 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1573 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1574 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1575 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1576 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1577 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1578 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1579 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1580 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1581 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1582 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1583 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1584 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1585 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1586 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1587 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1588 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1589 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1590 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1591 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1592 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1593 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1594 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1595 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1596 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1597 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1598 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1599 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1600 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1601 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1602 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1603 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1604 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1605 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1606 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1607 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1608 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1609 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1610 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1611 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1612 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1613 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1614 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1615 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1616 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1617 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1618 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1619 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1620 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1621 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1622 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1623 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1624 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1625 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1626 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1627 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1628 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1629 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1630 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1631 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1632 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1633 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1634 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1635 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1636 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1637 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1638 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1639 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1640 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1641 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1642 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1643 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1644 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1645 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1646 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1647 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1648 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1649 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1650 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1651 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1652 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1653 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1654 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1655 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1656 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1657 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1658 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1659 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1660 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1661 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1662 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1663 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1664 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1665 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1666 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1667 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1668 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1669 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1670 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1671 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1672 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1673 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1674 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1675 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1676 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1677 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1678 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1679 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1680 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1681 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1682 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1683 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1684 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1685 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1686 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1687 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1688 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1689 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1690 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1691 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1692 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1693 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1694 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1695 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1696 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1697 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1698 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1699 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1700 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1701 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1702 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1703 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1704 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1705 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1706 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1707 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1708 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1709 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1710 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1711 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1712 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1713 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1714 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1715 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1716 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1717 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1718 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1719 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1720 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1721 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1722 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1723 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1724 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1725 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1726 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1727 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1728 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1729 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1730 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1731 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1732 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1733 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1734 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1735 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1736 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1737 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1738 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1739 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1740 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1741 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1742 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1743 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1744 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1745 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1746 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1747 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1748 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1749 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1750 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1751 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1752 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1753 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1754 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1755 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1756 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1757 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1758 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1759 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1760 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1761 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1762 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1763 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1764 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1765 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1766 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1767 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1768 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1769 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1770 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1771 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1772 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1773 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1774 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1775 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1776 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1777 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1778 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1779 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1780 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1781 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1782 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1783 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1784 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1785 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1786 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1787 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1788 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1789 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1790 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1791 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1792 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1793 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1794 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1795 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1796 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1797 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1798 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1799 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1800 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1801 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1805 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1806 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1807 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1808 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1809 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1812 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1813 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1814 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1815 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1816 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1819 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1820 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1821 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1822 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1823 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1826 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1827 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1828 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1829 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1830 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1833 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1834 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1835 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1836 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1837 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1840 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1841 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1842 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1843 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1844 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1847 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1848 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1849 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1850 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1851 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1854 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1855 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1856 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1857 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1858 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1861 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1862 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1863 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1864 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1865 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1868 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1869 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1870 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1871 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1872 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1875 struct crypto_data_params {
1878 const char *plaintext;
1879 struct crypto_expected_output {
1880 const uint8_t *ciphertext;
1881 const uint8_t *digest;
1885 #define MAX_PACKET_SIZE_INDEX 10
1887 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1888 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1889 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1890 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1891 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1892 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1893 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1894 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1895 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1896 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1897 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1898 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1899 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1900 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1901 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1902 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1903 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1904 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1905 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1906 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1907 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1911 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1913 uint32_t num_to_submit = 4096;
1914 struct rte_crypto_op *c_ops[num_to_submit];
1915 struct rte_crypto_op *proc_ops[num_to_submit];
1916 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1917 uint32_t burst_sent, burst_received;
1918 uint32_t i, burst_size, num_sent, num_received;
1919 struct crypto_testsuite_params *ts_params = &testsuite_params;
1920 struct crypto_unittest_params *ut_params = &unittest_params;
1921 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1923 if (rte_cryptodev_count() == 0) {
1924 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1928 /* Setup Cipher Parameters */
1929 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1930 ut_params->cipher_xform.next = &ut_params->auth_xform;
1932 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1933 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1934 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1935 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1938 /* Setup HMAC Parameters */
1939 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1940 ut_params->auth_xform.next = NULL;
1942 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1943 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1944 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1945 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1946 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1948 /* Create Crypto session*/
1949 ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
1950 &ut_params->cipher_xform);
1952 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1954 /* Generate Crypto op data structure(s) */
1955 for (i = 0; i < num_to_submit ; i++) {
1956 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
1957 data_params[0].expected.ciphertext,
1958 data_params[0].length, 0);
1959 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
1961 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
1962 DIGEST_BYTE_LENGTH_SHA256);
1963 TEST_ASSERT_NOT_NULL(ut_params->digest,
1964 "no room to append digest");
1966 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1967 DIGEST_BYTE_LENGTH_SHA256);
1970 struct rte_crypto_op *op =
1971 rte_crypto_op_alloc(ts_params->op_mpool,
1972 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1974 rte_crypto_op_attach_sym_session(op, ut_params->sess);
1976 op->sym->auth.digest.data = ut_params->digest;
1977 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
1978 data_params[0].length);
1979 op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
1981 op->sym->auth.data.offset = 0;
1982 op->sym->auth.data.length = data_params[0].length;
1984 op->sym->cipher.iv.offset = IV_OFFSET;
1985 op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
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 if (chain != CIPHER_ONLY) {
2650 /* Setup HMAC Parameters */
2651 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2652 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2653 auth_xform.auth.algo = auth_algo;
2654 auth_xform.auth.key.data = hmac_sha_key;
2655 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2656 auth_xform.auth.digest_length =
2657 get_auth_digest_length(auth_algo);
2661 cipher_xform.next = &auth_xform;
2662 auth_xform.next = NULL;
2663 /* Create Crypto session*/
2664 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2666 auth_xform.next = &cipher_xform;
2667 cipher_xform.next = NULL;
2668 /* Create Crypto session*/
2669 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2671 cipher_xform.next = NULL;
2672 /* Create Crypto session*/
2673 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2679 #define SNOW3G_CIPHER_IV_LENGTH 16
2681 static struct rte_cryptodev_sym_session *
2682 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2683 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2684 enum rte_crypto_auth_algorithm auth_algo)
2686 struct rte_crypto_sym_xform cipher_xform = {0};
2687 struct rte_crypto_sym_xform auth_xform = {0};
2690 /* Setup Cipher Parameters */
2691 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2692 cipher_xform.cipher.algo = cipher_algo;
2693 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2695 cipher_xform.cipher.key.data = snow3g_cipher_key;
2696 cipher_xform.cipher.key.length = cipher_key_len;
2698 /* Setup HMAC Parameters */
2699 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2700 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2701 auth_xform.auth.algo = auth_algo;
2703 auth_xform.auth.add_auth_data_length = SNOW3G_CIPHER_IV_LENGTH;
2704 auth_xform.auth.key.data = snow3g_hash_key;
2705 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2706 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2710 cipher_xform.next = &auth_xform;
2711 auth_xform.next = NULL;
2712 /* Create Crypto session*/
2713 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2715 auth_xform.next = &cipher_xform;
2716 cipher_xform.next = NULL;
2717 /* Create Crypto session*/
2718 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2720 cipher_xform.next = NULL;
2721 /* Create Crypto session*/
2722 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2724 auth_xform.next = NULL;
2725 /* Create Crypto session */
2726 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2732 static struct rte_cryptodev_sym_session *
2733 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2734 enum rte_crypto_cipher_algorithm cipher_algo,
2735 unsigned int cipher_key_len,
2736 enum rte_crypto_auth_algorithm auth_algo)
2738 struct rte_crypto_sym_xform cipher_xform = { 0 };
2739 struct rte_crypto_sym_xform auth_xform = { 0 };
2741 /* Setup Cipher Parameters */
2742 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2743 cipher_xform.cipher.algo = cipher_algo;
2744 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2746 switch (cipher_algo) {
2747 case RTE_CRYPTO_CIPHER_3DES_CBC:
2748 case RTE_CRYPTO_CIPHER_3DES_CTR:
2749 cipher_xform.cipher.key.data = triple_des_key;
2751 case RTE_CRYPTO_CIPHER_AES_CBC:
2752 case RTE_CRYPTO_CIPHER_AES_CTR:
2753 case RTE_CRYPTO_CIPHER_AES_GCM:
2754 cipher_xform.cipher.key.data = aes_key;
2760 cipher_xform.cipher.key.length = cipher_key_len;
2762 /* Setup Auth Parameters */
2763 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2764 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2765 auth_xform.auth.algo = auth_algo;
2767 switch (auth_algo) {
2768 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2769 auth_xform.auth.key.data = hmac_sha_key;
2771 case RTE_CRYPTO_AUTH_AES_GCM:
2772 auth_xform.auth.key.data = NULL;
2778 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2779 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2783 cipher_xform.next = &auth_xform;
2784 auth_xform.next = NULL;
2785 /* Create Crypto session*/
2786 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2788 auth_xform.next = &cipher_xform;
2789 cipher_xform.next = NULL;
2790 /* Create Crypto session*/
2791 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2797 static struct rte_cryptodev_sym_session *
2798 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2799 enum rte_crypto_cipher_algorithm cipher_algo,
2800 unsigned int cipher_key_len,
2801 enum rte_crypto_auth_algorithm auth_algo)
2803 struct rte_crypto_sym_xform cipher_xform = { 0 };
2804 struct rte_crypto_sym_xform auth_xform = { 0 };
2806 /* Setup Cipher Parameters */
2807 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2808 cipher_xform.cipher.algo = cipher_algo;
2810 switch (cipher_algo) {
2811 case RTE_CRYPTO_CIPHER_AES_CBC:
2812 cipher_xform.cipher.key.data = aes_cbc_128_key;
2818 cipher_xform.cipher.key.length = cipher_key_len;
2820 /* Setup Auth Parameters */
2821 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2822 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2823 auth_xform.auth.algo = auth_algo;
2825 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2829 cipher_xform.next = &auth_xform;
2830 auth_xform.next = NULL;
2831 /* Encrypt and hash the result */
2832 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2833 /* Create Crypto session*/
2834 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2836 auth_xform.next = &cipher_xform;
2837 cipher_xform.next = NULL;
2838 /* Hash encrypted message and decrypt */
2839 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2840 /* Create Crypto session*/
2841 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2847 #define AES_CIPHER_IV_LENGTH 16
2848 #define AES_GCM_AAD_LENGTH 16
2849 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
2851 static struct rte_mbuf *
2852 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2854 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2856 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2857 rte_pktmbuf_free(m);
2861 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2866 static inline struct rte_crypto_op *
2867 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2868 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2869 unsigned int digest_len, enum chain_mode chain)
2871 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2872 rte_crypto_op_free(op);
2876 /* Authentication Parameters */
2877 if (chain == CIPHER_ONLY) {
2878 op->sym->auth.digest.data = NULL;
2879 op->sym->auth.digest.phys_addr = 0;
2880 op->sym->auth.digest.length = 0;
2881 op->sym->auth.aad.data = NULL;
2882 op->sym->auth.aad.length = 0;
2883 op->sym->auth.data.offset = 0;
2884 op->sym->auth.data.length = 0;
2886 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2887 uint8_t *, data_len);
2888 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2890 op->sym->auth.digest.length = digest_len;
2891 op->sym->auth.data.offset = 0;
2892 op->sym->auth.data.length = data_len;
2896 /* Cipher Parameters */
2897 op->sym->cipher.iv.offset = IV_OFFSET;
2898 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2899 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2900 aes_iv, AES_CIPHER_IV_LENGTH);
2902 op->sym->cipher.data.offset = 0;
2903 op->sym->cipher.data.length = data_len;
2910 static inline struct rte_crypto_op *
2911 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2912 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2913 unsigned int digest_len, enum chain_mode chain __rte_unused)
2915 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2916 rte_crypto_op_free(op);
2920 /* Authentication Parameters */
2921 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2922 (m->data_off + data_len);
2923 op->sym->auth.digest.phys_addr =
2924 rte_pktmbuf_mtophys_offset(m, data_len);
2925 op->sym->auth.digest.length = digest_len;
2926 op->sym->auth.aad.data = aes_gcm_aad;
2927 op->sym->auth.aad.length = AES_GCM_AAD_LENGTH;
2929 /* Cipher Parameters */
2930 op->sym->cipher.iv.offset = IV_OFFSET;
2931 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2932 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2933 aes_iv, AES_CIPHER_IV_LENGTH);
2935 /* Data lengths/offsets Parameters */
2936 op->sym->auth.data.offset = 0;
2937 op->sym->auth.data.length = data_len;
2939 op->sym->cipher.data.offset = 0;
2940 op->sym->cipher.data.length = data_len;
2947 static inline struct rte_crypto_op *
2948 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2949 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2950 unsigned digest_len)
2952 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
2953 uint8_t *, IV_OFFSET);
2955 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2956 rte_crypto_op_free(op);
2960 rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2962 /* Authentication Parameters */
2963 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2964 (m->data_off + data_len);
2965 op->sym->auth.digest.phys_addr =
2966 rte_pktmbuf_mtophys_offset(m, data_len);
2967 op->sym->auth.digest.length = digest_len;
2968 op->sym->auth.aad.data = iv_ptr;
2969 op->sym->auth.aad.phys_addr = rte_crypto_op_ctophys_offset(op,
2971 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
2973 /* Cipher Parameters */
2974 op->sym->cipher.iv.offset = IV_OFFSET;
2975 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2977 /* Data lengths/offsets Parameters */
2978 op->sym->auth.data.offset = 0;
2979 op->sym->auth.data.length = data_len << 3;
2981 op->sym->cipher.data.offset = 0;
2982 op->sym->cipher.data.length = data_len << 3;
2989 static inline struct rte_crypto_op *
2990 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2992 struct rte_cryptodev_sym_session *sess,
2995 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2996 rte_crypto_op_free(op);
3000 /* Cipher Parameters */
3001 op->sym->cipher.iv.offset = IV_OFFSET;
3002 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
3003 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3004 snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3006 op->sym->cipher.data.offset = 0;
3007 op->sym->cipher.data.length = data_len << 3;
3015 static inline struct rte_crypto_op *
3016 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3018 struct rte_cryptodev_sym_session *sess,
3020 unsigned digest_len)
3022 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3023 rte_crypto_op_free(op);
3027 /* Authentication Parameters */
3029 op->sym->auth.digest.data =
3030 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3032 op->sym->auth.digest.phys_addr =
3033 rte_pktmbuf_mtophys_offset(m, data_len +
3034 SNOW3G_CIPHER_IV_LENGTH);
3035 op->sym->auth.digest.length = digest_len;
3036 op->sym->auth.aad.data = rte_crypto_op_ctod_offset(op,
3037 uint8_t *, IV_OFFSET);
3038 op->sym->auth.aad.phys_addr = rte_crypto_op_ctophys_offset(op,
3040 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
3041 rte_memcpy(op->sym->auth.aad.data, snow3g_iv,
3042 SNOW3G_CIPHER_IV_LENGTH);
3044 /* Data lengths/offsets Parameters */
3045 op->sym->auth.data.offset = 0;
3046 op->sym->auth.data.length = data_len << 3;
3054 static inline struct rte_crypto_op *
3055 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3056 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3057 unsigned int digest_len, enum chain_mode chain __rte_unused)
3059 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3060 rte_crypto_op_free(op);
3064 /* Authentication Parameters */
3065 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3066 (m->data_off + data_len);
3067 op->sym->auth.digest.phys_addr =
3068 rte_pktmbuf_mtophys_offset(m, data_len);
3069 op->sym->auth.digest.length = digest_len;
3071 /* Cipher Parameters */
3072 op->sym->cipher.iv.offset = IV_OFFSET;
3073 op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
3074 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3075 triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3077 /* Data lengths/offsets Parameters */
3078 op->sym->auth.data.offset = 0;
3079 op->sym->auth.data.length = data_len;
3081 op->sym->cipher.data.offset = 0;
3082 op->sym->cipher.data.length = data_len;
3089 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3090 * same time, i.e. as they're not dereferenced there's no need to wait until
3091 * finished with to re-use */
3092 #define NUM_MBUF_SETS 8
3095 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3096 struct perf_test_params *pparams)
3098 uint16_t i, k, l, m;
3100 uint16_t ops_unused = 0;
3102 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3103 uint64_t processed = 0, failed_polls = 0, retries = 0;
3104 uint64_t tsc_start = 0, tsc_end = 0;
3106 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3108 struct rte_crypto_op *ops[pparams->burst_size];
3109 struct rte_crypto_op *proc_ops[pparams->burst_size];
3111 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3113 struct crypto_testsuite_params *ts_params = &testsuite_params;
3115 static struct rte_cryptodev_sym_session *sess;
3117 if (rte_cryptodev_count() == 0) {
3118 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3122 /* Create Crypto session*/
3123 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3124 pparams->chain, pparams->cipher_algo,
3125 pparams->cipher_key_length, pparams->auth_algo);
3126 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3128 /* Generate a burst of crypto operations */
3129 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3130 mbufs[i] = test_perf_create_pktmbuf(
3134 if (mbufs[i] == NULL) {
3135 printf("\nFailed to get mbuf - freeing the rest.\n");
3136 for (k = 0; k < i; k++)
3137 rte_pktmbuf_free(mbufs[k]);
3141 /* Make room for Digest in mbuf */
3142 if (pparams->chain != CIPHER_ONLY)
3143 rte_pktmbuf_append(mbufs[i], digest_length);
3147 tsc_start = rte_rdtsc_precise();
3149 while (total_enqueued < pparams->total_operations) {
3150 uint16_t burst_size =
3151 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3152 pparams->burst_size : pparams->total_operations-total_enqueued;
3153 uint16_t ops_needed = burst_size-ops_unused;
3155 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3156 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3157 printf("\nFailed to alloc enough ops, finish dequeuing "
3158 "and free ops below.");
3160 for (i = 0; i < ops_needed; i++)
3161 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3162 mbufs[i + (pparams->burst_size *
3163 (j % NUM_MBUF_SETS))],
3164 sess, pparams->buf_size, digest_length,
3168 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3169 queue_id, ops, burst_size);
3171 if (burst_enqueued < burst_size)
3174 ops_unused = burst_size-burst_enqueued;
3175 total_enqueued += burst_enqueued;
3179 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3180 proc_ops, pparams->burst_size);
3181 if (burst_dequeued == 0)
3184 processed += burst_dequeued;
3186 for (l = 0; l < burst_dequeued; l++)
3187 rte_crypto_op_free(proc_ops[l]);
3192 /* Dequeue any operations still in the crypto device */
3193 while (processed < pparams->total_operations) {
3194 /* Sending 0 length burst to flush sw crypto device */
3195 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3198 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3199 proc_ops, pparams->burst_size);
3200 if (burst_dequeued == 0)
3203 processed += burst_dequeued;
3205 for (m = 0; m < burst_dequeued; m++)
3206 rte_crypto_op_free(proc_ops[m]);
3210 tsc_end = rte_rdtsc_precise();
3212 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3213 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3215 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3216 throughput, retries, failed_polls);
3218 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3219 rte_pktmbuf_free(mbufs[i]);
3220 rte_cryptodev_sym_session_free(dev_id, sess);
3223 return TEST_SUCCESS;
3228 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3229 struct perf_test_params *pparams)
3231 uint16_t i, k, l, m;
3233 uint16_t ops_unused = 0;
3234 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3235 uint64_t processed = 0, failed_polls = 0, retries = 0;
3236 uint64_t tsc_start = 0, tsc_end = 0;
3238 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3240 struct rte_crypto_op *ops[pparams->burst_size];
3241 struct rte_crypto_op *proc_ops[pparams->burst_size];
3243 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3245 struct crypto_testsuite_params *ts_params = &testsuite_params;
3247 static struct rte_cryptodev_sym_session *sess;
3249 if (rte_cryptodev_count() == 0) {
3250 printf("\nNo crypto devices found. Is PMD build configured?\n");
3251 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3255 /* Create Crypto session*/
3256 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3257 pparams->chain, pparams->cipher_algo,
3258 pparams->cipher_key_length, pparams->auth_algo);
3259 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3261 /* Generate a burst of crypto operations */
3262 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3264 * Buffer size is allocated, for perf tests they
3265 * are equal + digest len.
3267 mbufs[i] = test_perf_create_pktmbuf(
3272 if (mbufs[i] == NULL) {
3273 printf("\nFailed to get mbuf - freeing the rest.\n");
3274 for (k = 0; k < i; k++)
3275 rte_pktmbuf_free(mbufs[k]);
3281 tsc_start = rte_rdtsc_precise();
3283 while (total_enqueued < pparams->total_operations) {
3284 uint16_t burst_size =
3285 (total_enqueued+pparams->burst_size)
3286 <= pparams->total_operations ?
3287 pparams->burst_size : pparams->total_operations-total_enqueued;
3288 uint16_t ops_needed = burst_size-ops_unused;
3289 /* Handle the last burst correctly */
3290 uint16_t op_offset = pparams->burst_size - burst_size;
3293 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3294 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3295 ops+op_offset, ops_needed)) {
3296 printf("\nFailed to alloc enough ops.");
3297 /*Don't exit, dequeue, more ops should become available*/
3299 for (i = 0; i < ops_needed; i++) {
3300 if (pparams->chain == HASH_ONLY)
3302 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3304 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3306 pparams->buf_size, digest_length);
3307 else if (pparams->chain == CIPHER_ONLY)
3309 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3311 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3320 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3321 ops+op_offset, burst_size);
3323 if (burst_enqueued < burst_size)
3326 ops_unused = burst_size-burst_enqueued;
3327 total_enqueued += burst_enqueued;
3331 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3332 proc_ops, pparams->burst_size);
3333 if (burst_dequeued == 0) {
3336 processed += burst_dequeued;
3337 for (l = 0; l < burst_dequeued; l++)
3338 rte_crypto_op_free(proc_ops[l]);
3343 /* Dequeue any operations still in the crypto device */
3344 while (processed < pparams->total_operations) {
3345 /* Sending 0 length burst to flush sw crypto device */
3346 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3349 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3350 proc_ops, pparams->burst_size);
3351 if (burst_dequeued == 0)
3354 processed += burst_dequeued;
3355 for (m = 0; m < burst_dequeued; m++)
3356 rte_crypto_op_free(proc_ops[m]);
3360 tsc_end = rte_rdtsc_precise();
3362 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3363 double cycles_burst = (double) (tsc_end - tsc_start) /
3364 (double) processed * pparams->burst_size;
3365 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3366 double cycles_B = cycles_buff / pparams->buf_size;
3367 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3369 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3370 /* Cycle count misleading on HW devices for this test, so don't print */
3371 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3372 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3373 pparams->buf_size, ops_s/1000000,
3374 throughput, retries, failed_polls);
3376 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3377 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3378 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3379 cycles_buff, cycles_B, retries, failed_polls);
3382 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3383 rte_pktmbuf_free(mbufs[i]);
3384 rte_cryptodev_sym_session_free(dev_id, sess);
3387 return TEST_SUCCESS;
3391 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3392 struct perf_test_params *pparams)
3394 uint16_t i, k, l, m;
3396 uint16_t ops_unused = 0;
3398 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3399 uint64_t processed = 0, failed_polls = 0, retries = 0;
3400 uint64_t tsc_start = 0, tsc_end = 0;
3402 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3404 struct rte_crypto_op *ops[pparams->burst_size];
3405 struct rte_crypto_op *proc_ops[pparams->burst_size];
3407 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3409 struct crypto_testsuite_params *ts_params = &testsuite_params;
3411 static struct rte_cryptodev_sym_session *sess;
3413 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3414 (struct rte_crypto_op *, struct rte_mbuf *,
3415 struct rte_cryptodev_sym_session *,
3416 unsigned int, unsigned int,
3419 switch (pparams->cipher_algo) {
3420 case RTE_CRYPTO_CIPHER_3DES_CBC:
3421 case RTE_CRYPTO_CIPHER_3DES_CTR:
3422 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3424 case RTE_CRYPTO_CIPHER_AES_CBC:
3425 case RTE_CRYPTO_CIPHER_AES_CTR:
3426 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3428 case RTE_CRYPTO_CIPHER_AES_GCM:
3429 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3435 if (rte_cryptodev_count() == 0) {
3436 printf("\nNo crypto devices found. Is PMD build configured?\n");
3440 /* Create Crypto session*/
3441 sess = test_perf_create_openssl_session(ts_params->dev_id,
3442 pparams->chain, pparams->cipher_algo,
3443 pparams->cipher_key_length, pparams->auth_algo);
3444 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3446 /* Generate a burst of crypto operations */
3447 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3448 mbufs[i] = test_perf_create_pktmbuf(
3452 if (mbufs[i] == NULL) {
3453 printf("\nFailed to get mbuf - freeing the rest.\n");
3454 for (k = 0; k < i; k++)
3455 rte_pktmbuf_free(mbufs[k]);
3460 tsc_start = rte_rdtsc_precise();
3462 while (total_enqueued < pparams->total_operations) {
3463 uint16_t burst_size =
3464 total_enqueued + pparams->burst_size <=
3465 pparams->total_operations ? pparams->burst_size :
3466 pparams->total_operations - total_enqueued;
3467 uint16_t ops_needed = burst_size - ops_unused;
3469 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3470 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3471 printf("\nFailed to alloc enough ops, finish dequeuing "
3472 "and free ops below.");
3474 for (i = 0; i < ops_needed; i++)
3475 ops[i] = test_perf_set_crypto_op(ops[i],
3476 mbufs[i + (pparams->burst_size *
3477 (j % NUM_MBUF_SETS))],
3478 sess, pparams->buf_size, digest_length,
3482 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3483 queue_id, ops, burst_size);
3485 if (burst_enqueued < burst_size)
3488 ops_unused = burst_size - burst_enqueued;
3489 total_enqueued += burst_enqueued;
3493 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3494 proc_ops, pparams->burst_size);
3495 if (burst_dequeued == 0)
3498 processed += burst_dequeued;
3500 for (l = 0; l < burst_dequeued; l++)
3501 rte_crypto_op_free(proc_ops[l]);
3506 /* Dequeue any operations still in the crypto device */
3507 while (processed < pparams->total_operations) {
3508 /* Sending 0 length burst to flush sw crypto device */
3509 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3512 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3513 proc_ops, pparams->burst_size);
3514 if (burst_dequeued == 0)
3517 processed += burst_dequeued;
3519 for (m = 0; m < burst_dequeued; m++)
3520 rte_crypto_op_free(proc_ops[m]);
3524 tsc_end = rte_rdtsc_precise();
3526 double ops_s = ((double)processed / (tsc_end - tsc_start))
3528 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3531 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3532 ops_s / 1000000, throughput, retries, failed_polls);
3534 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3535 rte_pktmbuf_free(mbufs[i]);
3536 rte_cryptodev_sym_session_free(dev_id, sess);
3539 return TEST_SUCCESS;
3543 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3544 struct perf_test_params *pparams)
3546 uint16_t i, k, l, m;
3548 uint16_t ops_unused = 0;
3549 uint16_t burst_size;
3550 uint16_t ops_needed;
3552 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3553 uint64_t processed = 0, failed_polls = 0, retries = 0;
3554 uint64_t tsc_start = 0, tsc_end = 0;
3556 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3558 struct rte_crypto_op *ops[pparams->burst_size];
3559 struct rte_crypto_op *proc_ops[pparams->burst_size];
3561 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3563 struct crypto_testsuite_params *ts_params = &testsuite_params;
3565 static struct rte_cryptodev_sym_session *sess;
3567 if (rte_cryptodev_count() == 0) {
3568 printf("\nNo crypto devices found. Is PMD build configured?\n");
3572 /* Create Crypto session*/
3573 sess = test_perf_create_armv8_session(ts_params->dev_id,
3574 pparams->chain, pparams->cipher_algo,
3575 pparams->cipher_key_length, pparams->auth_algo);
3576 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3578 /* Generate a burst of crypto operations */
3579 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3580 mbufs[i] = test_perf_create_pktmbuf(
3584 if (mbufs[i] == NULL) {
3585 printf("\nFailed to get mbuf - freeing the rest.\n");
3586 for (k = 0; k < i; k++)
3587 rte_pktmbuf_free(mbufs[k]);
3592 tsc_start = rte_rdtsc();
3594 while (total_enqueued < pparams->total_operations) {
3595 if ((total_enqueued + pparams->burst_size) <=
3596 pparams->total_operations)
3597 burst_size = pparams->burst_size;
3599 burst_size = pparams->total_operations - total_enqueued;
3601 ops_needed = burst_size - ops_unused;
3603 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3604 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3605 printf("\nFailed to alloc enough ops, finish dequeuing "
3606 "and free ops below.");
3608 for (i = 0; i < ops_needed; i++)
3609 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3610 mbufs[i + (pparams->burst_size *
3611 (j % NUM_MBUF_SETS))], sess,
3612 pparams->buf_size, digest_length,
3616 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3617 queue_id, ops, burst_size);
3619 if (burst_enqueued < burst_size)
3622 ops_unused = burst_size - burst_enqueued;
3623 total_enqueued += burst_enqueued;
3627 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3628 proc_ops, pparams->burst_size);
3629 if (burst_dequeued == 0)
3632 processed += burst_dequeued;
3634 for (l = 0; l < burst_dequeued; l++)
3635 rte_crypto_op_free(proc_ops[l]);
3640 /* Dequeue any operations still in the crypto device */
3641 while (processed < pparams->total_operations) {
3642 /* Sending 0 length burst to flush sw crypto device */
3643 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3646 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3647 proc_ops, pparams->burst_size);
3648 if (burst_dequeued == 0)
3651 processed += burst_dequeued;
3653 for (m = 0; m < burst_dequeued; m++)
3654 rte_crypto_op_free(proc_ops[m]);
3658 tsc_end = rte_rdtsc();
3660 double ops_s = ((double)processed / (tsc_end - tsc_start))
3662 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3665 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3666 ops_s / 1000000, throughput, retries, failed_polls);
3668 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3669 rte_pktmbuf_free(mbufs[i]);
3672 return TEST_SUCCESS;
3677 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3678 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3679 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3681 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3682 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3683 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3685 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3686 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3687 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3690 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3692 unsigned total_operations = 1000000;
3693 unsigned burst_size = 32;
3694 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3697 struct perf_test_params params_set[] = {
3699 .chain = CIPHER_ONLY,
3700 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3701 .cipher_key_length = 16,
3702 .auth_algo = RTE_CRYPTO_AUTH_NULL
3705 .chain = CIPHER_HASH,
3706 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3707 .cipher_key_length = 16,
3708 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3711 .chain = CIPHER_HASH,
3713 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3714 .cipher_key_length = 16,
3715 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3718 .chain = CIPHER_HASH,
3720 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3721 .cipher_key_length = 16,
3722 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3725 .chain = CIPHER_HASH,
3727 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3728 .cipher_key_length = 32,
3729 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3732 .chain = CIPHER_HASH,
3734 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3735 .cipher_key_length = 32,
3736 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3739 .chain = CIPHER_HASH,
3741 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3742 .cipher_key_length = 32,
3743 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3747 for (i = 0; i < RTE_DIM(params_set); i++) {
3749 params_set[i].total_operations = total_operations;
3750 params_set[i].burst_size = burst_size;
3751 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3752 " burst_size: %d ops\n",
3753 chain_mode_name(params_set[i].chain),
3754 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3755 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3756 params_set[i].cipher_key_length,
3758 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3759 "Retries\tEmptyPolls\n");
3760 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3761 params_set[i].buf_size = buf_lengths[j];
3762 test_perf_aes_sha(testsuite_params.dev_id, 0,
3770 test_perf_snow3G_vary_pkt_size(void)
3772 unsigned total_operations = 1000000;
3775 uint16_t burst_sizes[] = { 64 };
3776 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3778 struct perf_test_params params_set[] = {
3780 .chain = CIPHER_ONLY,
3781 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3782 .cipher_key_length = 16,
3783 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3787 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3788 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3789 .cipher_key_length = 16
3793 printf("\n\nStart %s.", __func__);
3794 printf("\nTest to measure max throughput at various pkt sizes.");
3795 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3796 " so cycle cost not relevant (n/a displayed).");
3798 for (i = 0; i < RTE_DIM(params_set); i++) {
3800 params_set[i].total_operations = total_operations;
3801 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3802 enum rte_crypto_cipher_algorithm cipher_algo =
3803 params_set[i].cipher_algo;
3804 enum rte_crypto_auth_algorithm auth_algo =
3805 params_set[i].auth_algo;
3806 printf("\nOn %s dev%u qp%u, %s, "
3807 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3808 pmd_name(gbl_cryptodev_perftest_devtype),
3809 testsuite_params.dev_id, 0,
3810 chain_mode_name(params_set[i].chain),
3811 rte_crypto_cipher_algorithm_strings[cipher_algo],
3812 rte_crypto_auth_algorithm_strings[auth_algo],
3815 params_set[i].burst_size = burst_sizes[k];
3816 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3817 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3818 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3820 params_set[i].buf_size = buf_lengths[j];
3822 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3831 test_perf_openssl_vary_pkt_size(void)
3833 unsigned int total_operations = 10000;
3834 unsigned int burst_size = { 64 };
3835 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3839 struct perf_test_params params_set[] = {
3841 .chain = CIPHER_HASH,
3843 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3844 .cipher_key_length = 16,
3845 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3848 .chain = CIPHER_HASH,
3850 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3851 .cipher_key_length = 24,
3852 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3855 .chain = CIPHER_HASH,
3857 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3858 .cipher_key_length = 16,
3859 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3862 .chain = CIPHER_HASH,
3864 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3865 .cipher_key_length = 32,
3866 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3869 .chain = CIPHER_HASH,
3871 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3872 .cipher_key_length = 16,
3873 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3876 .chain = CIPHER_HASH,
3878 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3879 .cipher_key_length = 24,
3880 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3883 .chain = CIPHER_HASH,
3885 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3886 .cipher_key_length = 16,
3887 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3891 for (i = 0; i < RTE_DIM(params_set); i++) {
3892 params_set[i].total_operations = total_operations;
3893 params_set[i].burst_size = burst_size;
3894 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3895 " burst_size: %d ops\n",
3896 chain_mode_name(params_set[i].chain),
3897 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3898 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3899 params_set[i].cipher_key_length,
3901 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3903 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3904 params_set[i].buf_size = buf_lengths[j];
3905 test_perf_openssl(testsuite_params.dev_id, 0,
3914 test_perf_openssl_vary_burst_size(void)
3916 unsigned int total_operations = 4096;
3917 uint16_t buf_lengths[] = { 40 };
3920 struct perf_test_params params_set[] = {
3922 .chain = CIPHER_HASH,
3924 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3925 .cipher_key_length = 16,
3926 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3929 .chain = CIPHER_HASH,
3931 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3932 .cipher_key_length = 24,
3933 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3936 .chain = CIPHER_HASH,
3938 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3939 .cipher_key_length = 16,
3940 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3943 .chain = CIPHER_HASH,
3945 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3946 .cipher_key_length = 32,
3947 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3950 .chain = CIPHER_HASH,
3952 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3953 .cipher_key_length = 16,
3954 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3957 .chain = CIPHER_HASH,
3959 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3960 .cipher_key_length = 24,
3961 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3964 .chain = CIPHER_HASH,
3966 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3967 .cipher_key_length = 16,
3968 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3972 printf("\n\nStart %s.", __func__);
3973 printf("\nThis Test measures the average IA cycle cost using a "
3974 "constant request(packet) size. ");
3975 printf("Cycle cost is only valid when indicators show device is not"
3976 " busy, i.e. Retries and EmptyPolls = 0");
3978 for (i = 0; i < RTE_DIM(params_set); i++) {
3980 params_set[i].total_operations = total_operations;
3982 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3983 params_set[i].buf_size = buf_lengths[j];
3984 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3992 test_perf_armv8_vary_pkt_size(void)
3994 unsigned int total_operations = 100000;
3995 unsigned int burst_size = { 64 };
3996 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
4000 struct perf_test_params params_set[] = {
4002 .chain = CIPHER_HASH,
4004 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4005 .cipher_key_length = 16,
4006 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4009 .chain = HASH_CIPHER,
4011 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4012 .cipher_key_length = 16,
4013 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4016 .chain = CIPHER_HASH,
4018 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4019 .cipher_key_length = 16,
4020 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4023 .chain = HASH_CIPHER,
4025 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4026 .cipher_key_length = 16,
4027 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4031 for (i = 0; i < RTE_DIM(params_set); i++) {
4032 params_set[i].total_operations = total_operations;
4033 params_set[i].burst_size = burst_size;
4034 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4035 " burst_size: %d ops\n",
4036 chain_mode_name(params_set[i].chain),
4037 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4038 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4039 params_set[i].cipher_key_length,
4041 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4043 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4044 params_set[i].buf_size = buf_lengths[j];
4045 test_perf_armv8(testsuite_params.dev_id, 0,
4054 test_perf_armv8_vary_burst_size(void)
4056 unsigned int total_operations = 4096;
4057 uint16_t buf_lengths[] = { 64 };
4060 struct perf_test_params params_set[] = {
4062 .chain = CIPHER_HASH,
4064 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4065 .cipher_key_length = 16,
4066 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4069 .chain = HASH_CIPHER,
4071 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4072 .cipher_key_length = 16,
4073 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4076 .chain = CIPHER_HASH,
4078 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4079 .cipher_key_length = 16,
4080 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4083 .chain = HASH_CIPHER,
4085 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4086 .cipher_key_length = 16,
4087 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4091 printf("\n\nStart %s.", __func__);
4092 printf("\nThis Test measures the average IA cycle cost using a "
4093 "constant request(packet) size. ");
4094 printf("Cycle cost is only valid when indicators show device is "
4095 "not busy, i.e. Retries and EmptyPolls = 0");
4097 for (i = 0; i < RTE_DIM(params_set); i++) {
4099 params_set[i].total_operations = total_operations;
4101 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4102 params_set[i].buf_size = buf_lengths[j];
4103 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4111 test_perf_aes_cbc_vary_burst_size(void)
4113 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4117 static struct rte_cryptodev_sym_session *
4118 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4120 static struct rte_cryptodev_sym_session *sess;
4121 struct rte_crypto_sym_xform cipher_xform = { 0 };
4122 struct rte_crypto_sym_xform auth_xform = { 0 };
4124 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4125 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4127 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4128 pparams->session_attrs->key_cipher_len);
4129 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4130 pparams->session_attrs->key_auth_len);
4132 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4133 cipher_xform.next = NULL;
4135 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4136 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4137 cipher_xform.cipher.key.data = cipher_key;
4138 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4140 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4141 auth_xform.next = NULL;
4143 auth_xform.auth.op = pparams->session_attrs->auth;
4144 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4146 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4147 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4150 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4151 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4152 cipher_xform.next = &auth_xform;
4153 sess = rte_cryptodev_sym_session_create(dev_id,
4156 auth_xform.next = &cipher_xform;
4157 sess = rte_cryptodev_sym_session_create(dev_id,
4164 static inline struct rte_crypto_op *
4165 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4166 struct rte_cryptodev_sym_session *sess,
4167 struct crypto_params *m_hlp,
4168 struct perf_test_params *params)
4170 uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4171 uint8_t *, IV_OFFSET);
4173 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4174 rte_crypto_op_free(op);
4178 op->sym->auth.digest.data = m_hlp->digest;
4179 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4181 params->symmetric_op->aad_len +
4182 params->symmetric_op->p_len);
4184 op->sym->auth.digest.length = params->symmetric_op->t_len;
4186 op->sym->auth.aad.data = m_hlp->aad;
4187 op->sym->auth.aad.length = params->symmetric_op->aad_len;
4188 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
4190 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4191 params->symmetric_op->aad_len);
4193 op->sym->cipher.iv.offset = IV_OFFSET;
4194 rte_memcpy(iv_ptr, params->symmetric_op->iv_data,
4195 params->symmetric_op->iv_len);
4196 if (params->symmetric_op->iv_len == 12)
4199 op->sym->cipher.iv.length = params->symmetric_op->iv_len;
4201 op->sym->auth.data.offset =
4202 params->symmetric_op->aad_len;
4203 op->sym->auth.data.length = params->symmetric_op->p_len;
4205 op->sym->cipher.data.offset =
4206 params->symmetric_op->aad_len;
4207 op->sym->cipher.data.length = params->symmetric_op->p_len;
4214 static struct rte_mbuf *
4215 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4216 struct perf_test_params *params,
4217 unsigned buf_sz, struct crypto_params *m_hlp)
4219 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4220 uint16_t aad_len = params->symmetric_op->aad_len;
4221 uint16_t digest_size = params->symmetric_op->t_len;
4224 p = rte_pktmbuf_append(m, aad_len);
4226 rte_pktmbuf_free(m);
4229 m_hlp->aad = (uint8_t *)p;
4231 p = rte_pktmbuf_append(m, buf_sz);
4233 rte_pktmbuf_free(m);
4236 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4238 p = rte_pktmbuf_append(m, digest_size);
4240 rte_pktmbuf_free(m);
4243 m_hlp->digest = (uint8_t *)p;
4249 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4250 struct perf_test_params *pparams, uint32_t test_ops)
4253 struct crypto_testsuite_params *ts_params = &testsuite_params;
4254 struct rte_cryptodev_sym_session *sess;
4255 struct rte_crypto_op *ops[pparams->burst_size];
4256 struct rte_crypto_op *proc_ops[pparams->burst_size];
4257 uint32_t total_operations = pparams->total_operations;
4259 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4260 uint64_t processed = 0, failed_polls = 0, retries = 0;
4261 uint64_t tsc_start = 0, tsc_end = 0;
4263 uint16_t i = 0, l = 0, m = 0;
4264 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4265 uint16_t ops_unused = 0;
4267 struct rte_mbuf *mbufs[burst];
4268 struct crypto_params m_hlp[burst];
4270 if (rte_cryptodev_count() == 0) {
4271 printf("\nNo crypto devices available. "
4272 "Is kernel driver loaded?\n");
4276 sess = test_perf_create_session(dev_id, pparams);
4277 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4279 for (i = 0; i < burst; i++) {
4280 mbufs[i] = test_perf_create_pktmbuf_fill(
4282 pparams, pparams->symmetric_op->p_len,
4287 total_operations = test_ops;
4289 tsc_start = rte_rdtsc_precise();
4290 while (total_enqueued < total_operations) {
4291 uint16_t burst_size =
4292 total_enqueued+pparams->burst_size <= total_operations ?
4293 pparams->burst_size : total_operations-total_enqueued;
4294 uint16_t ops_needed = burst_size-ops_unused;
4296 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4297 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4298 printf("\nFailed to alloc enough ops, "
4299 "finish dequeuing");
4301 for (i = 0; i < ops_needed; i++)
4302 ops[i] = perf_gcm_set_crypto_op(ops[i],
4303 mbufs[i + (pparams->burst_size *
4304 (j % NUM_MBUF_SETS))],
4305 sess, &m_hlp[i + (pparams->burst_size *
4306 (j % NUM_MBUF_SETS))], pparams);
4309 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4310 queue_id, ops, burst_size);
4312 if (burst_enqueued < burst_size)
4315 ops_unused = burst_size-burst_enqueued;
4316 total_enqueued += burst_enqueued;
4320 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4321 proc_ops, pparams->burst_size);
4322 if (burst_dequeued == 0)
4325 processed += burst_dequeued;
4327 for (l = 0; l < burst_dequeued; l++)
4328 rte_crypto_op_free(proc_ops[l]);
4334 /* Dequeue any operations still in the crypto device */
4335 while (processed < total_operations) {
4336 /* Sending 0 length burst to flush sw crypto device */
4337 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4340 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4341 proc_ops, pparams->burst_size);
4342 if (burst_dequeued == 0)
4345 processed += burst_dequeued;
4347 for (m = 0; m < burst_dequeued; m++) {
4349 uint8_t *pkt = rte_pktmbuf_mtod(
4350 proc_ops[m]->sym->m_src,
4353 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4354 pparams->symmetric_op->c_data,
4356 pparams->symmetric_op->aad_len,
4357 pparams->symmetric_op->c_len,
4358 "GCM Ciphertext data not as expected");
4360 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4361 pparams->symmetric_op->t_data,
4363 pparams->symmetric_op->aad_len +
4364 pparams->symmetric_op->c_len,
4365 pparams->symmetric_op->t_len,
4366 "GCM MAC data not as expected");
4369 rte_crypto_op_free(proc_ops[m]);
4374 tsc_end = rte_rdtsc_precise();
4376 double ops_s = ((double)processed / (tsc_end - tsc_start))
4378 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4382 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4383 pparams->symmetric_op->p_len,
4384 ops_s/1000000, throughput, retries, failed_polls);
4387 for (i = 0; i < burst; i++)
4388 rte_pktmbuf_free(mbufs[i]);
4389 rte_cryptodev_sym_session_free(dev_id, sess);
4395 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4397 uint16_t i, j, k, loops = 1;
4399 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4401 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4402 &AES_GCM_128_12IV_0AAD
4405 if (continual_buf_len)
4406 loops = continual_size;
4408 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4410 const unsigned burst_size = 32;
4412 struct symmetric_op ops_set[TEST_CASES_GCM];
4413 struct perf_test_params params_set[TEST_CASES_GCM];
4414 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4415 static const struct cryptodev_perf_test_data *gcm_test;
4417 for (i = 0; i < TEST_CASES_GCM; ++i) {
4419 gcm_test = gcm_tests[i];
4421 session_attrs[i].cipher =
4422 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4423 session_attrs[i].cipher_algorithm =
4424 RTE_CRYPTO_CIPHER_AES_GCM;
4425 session_attrs[i].key_cipher_data =
4427 session_attrs[i].key_cipher_len =
4429 session_attrs[i].auth_algorithm =
4430 RTE_CRYPTO_AUTH_AES_GCM;
4431 session_attrs[i].auth =
4432 RTE_CRYPTO_AUTH_OP_GENERATE;
4433 session_attrs[i].key_auth_data = NULL;
4434 session_attrs[i].key_auth_len = 0;
4435 session_attrs[i].digest_len =
4436 gcm_test->auth_tag.len;
4438 ops_set[i].aad_data = gcm_test->aad.data;
4439 ops_set[i].aad_len = gcm_test->aad.len;
4440 ops_set[i].iv_data = gcm_test->iv.data;
4441 ops_set[i].iv_len = gcm_test->iv.len;
4442 ops_set[i].p_data = gcm_test->plaintext.data;
4443 ops_set[i].p_len = buf_lengths[i];
4444 ops_set[i].c_data = gcm_test->ciphertext.data;
4445 ops_set[i].c_len = buf_lengths[i];
4446 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4447 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4449 params_set[i].chain = CIPHER_HASH;
4450 params_set[i].session_attrs = &session_attrs[i];
4451 params_set[i].symmetric_op = &ops_set[i];
4452 if (continual_buf_len)
4453 params_set[i].total_operations = 0xFFFFFF;
4455 params_set[i].total_operations = 1000000;
4457 params_set[i].burst_size = burst_size;
4461 if (continual_buf_len)
4462 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4463 " burst size: %u", "AES_GCM", "AES_GCM",
4464 gcm_test->key.len << 3, burst_size);
4466 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4468 if (!continual_buf_len) {
4469 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4470 " burst size: %u", "AES_GCM", "AES_GCM",
4471 gcm_test->key.len << 3, burst_size);
4472 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4473 " Retries\tEmptyPolls");
4476 uint16_t len = RTE_DIM(buf_lengths);
4479 if (continual_buf_len) {
4480 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4481 if (buf_lengths[k] == continual_buf_len) {
4487 for (j = p; j < len; ++j) {
4489 params_set[i].symmetric_op->c_len = buf_lengths[j];
4490 params_set[i].symmetric_op->p_len = buf_lengths[j];
4492 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4493 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4495 /* Run is twice, one for encryption/hash checks,
4498 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4502 for (k = 0; k < loops; k++) {
4503 if (continual_buf_len)
4504 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4505 "Throughput(Gbps)\t"
4506 "Retries\tEmptyPolls");
4507 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4510 if (continual_buf_len)
4511 printf("\n\nCompleted loop %i of %i ...",
4521 static int test_cryptodev_perf_AES_GCM(void)
4523 return test_perf_AES_GCM(0, 0);
4526 * This function calls AES GCM performance tests providing
4527 * size of packet as an argument. If size of packet is not
4528 * in the buf_lengths array, all sizes will be used
4530 static int test_continual_perf_AES_GCM(void)
4532 return test_perf_AES_GCM(1024, 10);
4536 test_perf_continual_performance_test(void)
4538 unsigned int total_operations = 0xFFFFFF;
4539 unsigned int total_loops = 10;
4540 unsigned int burst_size = 32;
4543 struct perf_test_params params_set = {
4544 .total_operations = total_operations,
4545 .burst_size = burst_size,
4548 .chain = CIPHER_HASH,
4550 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4551 .cipher_key_length = 16,
4552 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4555 for (i = 1; i <= total_loops; ++i) {
4556 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4557 " burst_size: %d ops\n",
4558 chain_mode_name(params_set.chain),
4559 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4560 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4561 params_set.cipher_key_length,
4563 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4564 "Retries\tEmptyPolls\n");
4565 test_perf_aes_sha(testsuite_params.dev_id, 0,
4567 printf("\nCompleted loop %i of %i ...", i, total_loops);
4572 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4573 .suite_name = "Crypto Device Continual Performance Test",
4574 .setup = testsuite_setup,
4575 .teardown = testsuite_teardown,
4576 .unit_test_cases = {
4577 TEST_CASE_ST(ut_setup, ut_teardown,
4578 test_perf_continual_performance_test),
4579 TEST_CASE_ST(ut_setup, ut_teardown,
4580 test_continual_perf_AES_GCM),
4581 TEST_CASES_END() /**< NULL terminate unit test array */
4585 static struct unit_test_suite cryptodev_testsuite = {
4586 .suite_name = "Crypto Device Unit Test Suite",
4587 .setup = testsuite_setup,
4588 .teardown = testsuite_teardown,
4589 .unit_test_cases = {
4590 TEST_CASE_ST(ut_setup, ut_teardown,
4591 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4592 TEST_CASE_ST(ut_setup, ut_teardown,
4593 test_cryptodev_perf_AES_GCM),
4594 TEST_CASE_ST(ut_setup, ut_teardown,
4595 test_perf_aes_cbc_vary_burst_size),
4596 TEST_CASES_END() /**< NULL terminate unit test array */
4600 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4601 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4602 .setup = testsuite_setup,
4603 .teardown = testsuite_teardown,
4604 .unit_test_cases = {
4605 TEST_CASE_ST(ut_setup, ut_teardown,
4606 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4607 TEST_CASES_END() /**< NULL terminate unit test array */
4611 static struct unit_test_suite cryptodev_gcm_testsuite = {
4612 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4613 .setup = testsuite_setup,
4614 .teardown = testsuite_teardown,
4615 .unit_test_cases = {
4616 TEST_CASE_ST(ut_setup, ut_teardown,
4617 test_cryptodev_perf_AES_GCM),
4618 TEST_CASES_END() /**< NULL terminate unit test array */
4622 static struct unit_test_suite cryptodev_aes_testsuite = {
4623 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4624 .setup = testsuite_setup,
4625 .teardown = testsuite_teardown,
4626 .unit_test_cases = {
4627 TEST_CASE_ST(ut_setup, ut_teardown,
4628 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4629 TEST_CASES_END() /**< NULL terminate unit test array */
4633 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4634 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4635 .setup = testsuite_setup,
4636 .teardown = testsuite_teardown,
4637 .unit_test_cases = {
4638 TEST_CASE_ST(ut_setup, ut_teardown,
4639 test_perf_snow3G_vary_pkt_size),
4640 TEST_CASE_ST(ut_setup, ut_teardown,
4641 test_perf_snow3G_vary_burst_size),
4642 TEST_CASES_END() /**< NULL terminate unit test array */
4646 static struct unit_test_suite cryptodev_openssl_testsuite = {
4647 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4648 .setup = testsuite_setup,
4649 .teardown = testsuite_teardown,
4650 .unit_test_cases = {
4651 TEST_CASE_ST(ut_setup, ut_teardown,
4652 test_perf_openssl_vary_pkt_size),
4653 TEST_CASE_ST(ut_setup, ut_teardown,
4654 test_perf_openssl_vary_burst_size),
4655 TEST_CASES_END() /**< NULL terminate unit test array */
4659 static struct unit_test_suite cryptodev_armv8_testsuite = {
4660 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4661 .setup = testsuite_setup,
4662 .teardown = testsuite_teardown,
4663 .unit_test_cases = {
4664 TEST_CASE_ST(ut_setup, ut_teardown,
4665 test_perf_armv8_vary_pkt_size),
4666 TEST_CASE_ST(ut_setup, ut_teardown,
4667 test_perf_armv8_vary_burst_size),
4668 TEST_CASES_END() /**< NULL terminate unit test array */
4673 perftest_aesni_gcm_cryptodev(void)
4675 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4677 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4681 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4683 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4685 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4689 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4691 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4693 return unit_test_suite_runner(&cryptodev_testsuite);
4697 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4699 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4701 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4705 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4707 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4709 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4713 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4715 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4717 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4721 perftest_qat_continual_cryptodev(void)
4723 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4725 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4729 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4731 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4733 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4737 perftest_dpaa2_sec_cryptodev(void)
4739 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4741 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4744 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4745 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4746 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4747 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4748 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4749 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4750 perftest_openssl_cryptodev);
4751 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4752 perftest_qat_continual_cryptodev);
4753 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4754 perftest_sw_armv8_cryptodev);
4755 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4756 perftest_dpaa2_sec_cryptodev);