4 * Copyright(c) 2015-2016 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 {
117 struct perf_test_params {
119 unsigned total_operations;
123 enum chain_mode chain;
125 enum rte_crypto_cipher_algorithm cipher_algo;
126 unsigned cipher_key_length;
127 enum rte_crypto_auth_algorithm auth_algo;
129 struct symmetric_session_attrs *session_attrs;
131 struct symmetric_op *symmetric_op;
134 #define MAX_NUM_OF_OPS_PER_UT (128)
136 struct crypto_unittest_params {
137 struct rte_crypto_sym_xform cipher_xform;
138 struct rte_crypto_sym_xform auth_xform;
140 struct rte_cryptodev_sym_session *sess;
142 struct rte_crypto_op *op;
144 struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
145 struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
150 static struct rte_cryptodev_sym_session *
151 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
152 enum rte_crypto_cipher_algorithm cipher_algo,
153 unsigned int cipher_key_len,
154 enum rte_crypto_auth_algorithm auth_algo);
155 static struct rte_cryptodev_sym_session *
156 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
157 enum rte_crypto_cipher_algorithm cipher_algo,
158 unsigned int cipher_key_len,
159 enum rte_crypto_auth_algorithm auth_algo);
160 static struct rte_cryptodev_sym_session *
161 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
162 enum rte_crypto_cipher_algorithm cipher_algo,
163 unsigned int cipher_key_len,
164 enum rte_crypto_auth_algorithm auth_algo);
166 static struct rte_mbuf *
167 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
168 static inline struct rte_crypto_op *
169 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
170 struct rte_cryptodev_sym_session *sess, unsigned data_len,
171 unsigned digest_len);
172 static inline struct rte_crypto_op *
173 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
174 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
175 unsigned int digest_len, enum chain_mode chain);
176 static inline struct rte_crypto_op *
177 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
178 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
179 unsigned int digest_len, enum chain_mode chain __rte_unused);
180 static inline struct rte_crypto_op *
181 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
182 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
183 unsigned int digest_len, enum chain_mode chain __rte_unused);
184 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
187 static const char *chain_mode_name(enum chain_mode mode)
190 case CIPHER_HASH: return "cipher_hash"; break;
191 case HASH_CIPHER: return "hash_cipher"; break;
192 case CIPHER_ONLY: return "cipher_only"; break;
193 case HASH_ONLY: return "hash_only"; break;
194 default: return ""; break;
198 static const char *pmd_name(enum rte_cryptodev_type pmd)
201 case RTE_CRYPTODEV_NULL_PMD: return RTE_STR(CRYPTODEV_NAME_NULL_PMD); break;
202 case RTE_CRYPTODEV_AESNI_GCM_PMD:
203 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
204 case RTE_CRYPTODEV_AESNI_MB_PMD:
205 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
206 case RTE_CRYPTODEV_QAT_SYM_PMD:
207 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
208 case RTE_CRYPTODEV_SNOW3G_PMD:
209 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
210 case RTE_CRYPTODEV_DPAA2_SEC_PMD:
211 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
217 static struct rte_mbuf *
218 setup_test_string(struct rte_mempool *mpool,
219 const uint8_t *data, size_t len, uint8_t blocksize)
221 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
222 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
225 char *dst = rte_pktmbuf_append(m, t_len);
232 rte_memcpy(dst, (const void *)data, t_len);
237 static struct crypto_testsuite_params testsuite_params = { NULL };
238 static struct crypto_unittest_params unittest_params;
239 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
242 testsuite_setup(void)
244 struct crypto_testsuite_params *ts_params = &testsuite_params;
245 struct rte_cryptodev_info info;
246 unsigned i, nb_devs, valid_dev_id = 0;
250 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
251 if (ts_params->mbuf_mp == NULL) {
252 /* Not already created so create */
253 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
254 "CRYPTO_PERF_MBUFPOOL",
255 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
257 if (ts_params->mbuf_mp == NULL) {
258 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
264 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
265 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
266 NUM_MBUFS, MBUF_CACHE_SIZE,
268 sizeof(struct rte_crypto_sym_xform),
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 = CIPHER_IV_LENGTH_AES_CBC;
1982 op->sym->auth.data.length = data_params[0].length;
1985 op->sym->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(m,
1986 CIPHER_IV_LENGTH_AES_CBC);
1987 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
1988 op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1990 rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv,
1991 CIPHER_IV_LENGTH_AES_CBC);
1993 op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
1994 op->sym->cipher.data.length = data_params[0].length;
2001 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
2002 "algorithm with a constant request size of %u.",
2003 data_params[0].length);
2004 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2005 "cost for each request.");
2006 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2007 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2008 "(assuming 0 retries)");
2009 for (i = 2; i <= 128 ; i *= 2) {
2016 while (num_sent < num_to_submit) {
2017 start_cycles = rte_rdtsc_precise();
2018 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2019 0, &c_ops[num_sent],
2020 ((num_to_submit-num_sent) < burst_size) ?
2021 num_to_submit-num_sent : burst_size);
2022 if (burst_sent == 0)
2025 num_sent += burst_sent;
2026 end_cycles = rte_rdtsc_precise();
2027 total_cycles += (end_cycles - start_cycles);
2029 * Wait until requests have been sent.
2033 start_cycles = rte_rdtsc_precise();
2034 burst_received = rte_cryptodev_dequeue_burst(
2035 dev_num, 0, proc_ops, burst_size);
2036 if (burst_received == 0)
2039 num_received += burst_received;
2040 end_cycles = rte_rdtsc_precise();
2041 total_cycles += end_cycles - start_cycles;
2044 while (num_received != num_to_submit) {
2045 if (gbl_cryptodev_perftest_devtype ==
2046 RTE_CRYPTODEV_AESNI_MB_PMD)
2047 rte_cryptodev_enqueue_burst(dev_num, 0,
2050 burst_received = rte_cryptodev_dequeue_burst(
2051 dev_num, 0, proc_ops, burst_size);
2052 if (burst_received == 0)
2055 num_received += burst_received;
2058 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2059 num_sent, num_received, burst_size);
2060 printf("\t\t%"PRIu64, retries);
2061 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2065 for (i = 0; i < num_to_submit ; i++) {
2066 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2067 rte_crypto_op_free(c_ops[i]);
2069 return TEST_SUCCESS;
2073 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2075 uint32_t num_to_submit = pparams->total_operations;
2076 struct rte_crypto_op *c_ops[num_to_submit];
2077 struct rte_crypto_op *proc_ops[num_to_submit];
2078 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2079 uint32_t burst_sent = 0, burst_received = 0;
2080 uint32_t i, burst_size, num_sent, num_ops_received;
2081 struct crypto_testsuite_params *ts_params = &testsuite_params;
2082 static struct rte_cryptodev_sym_session *sess;
2084 if (rte_cryptodev_count() == 0) {
2085 printf("\nNo crypto devices found. Is PMD build configured?\n");
2086 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2090 /* Create Crypto session*/
2091 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2092 pparams->chain, pparams->cipher_algo,
2093 pparams->cipher_key_length, pparams->auth_algo);
2094 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2096 /* Generate Crypto op data structure(s)*/
2097 for (i = 0; i < num_to_submit ; i++) {
2098 struct rte_mbuf *m = test_perf_create_pktmbuf(
2101 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2103 struct rte_crypto_op *op =
2104 rte_crypto_op_alloc(ts_params->op_mpool,
2105 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2106 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2108 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size,
2109 get_auth_digest_length(pparams->auth_algo));
2110 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2115 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2116 "Packet Size %u bytes",
2117 pmd_name(gbl_cryptodev_perftest_devtype),
2118 ts_params->dev_id, 0,
2119 chain_mode_name(pparams->chain),
2120 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2121 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2123 printf("\nOps Tx\tOps Rx\tOps/burst ");
2124 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2126 for (i = 2; i <= 128 ; i *= 2) {
2128 num_ops_received = 0;
2133 while (num_sent < num_to_submit) {
2134 start_cycles = rte_rdtsc_precise();
2135 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2136 0, &c_ops[num_sent],
2137 ((num_to_submit-num_sent) < burst_size) ?
2138 num_to_submit-num_sent : burst_size);
2139 end_cycles = rte_rdtsc_precise();
2140 if (burst_sent == 0)
2142 num_sent += burst_sent;
2143 total_cycles += (end_cycles - start_cycles);
2145 /* Wait until requests have been sent. */
2149 start_cycles = rte_rdtsc_precise();
2150 burst_received = rte_cryptodev_dequeue_burst(
2151 ts_params->dev_id, 0, proc_ops, burst_size);
2152 end_cycles = rte_rdtsc_precise();
2153 if (burst_received < burst_sent)
2155 num_ops_received += burst_received;
2157 total_cycles += end_cycles - start_cycles;
2160 while (num_ops_received != num_to_submit) {
2161 if (gbl_cryptodev_perftest_devtype ==
2162 RTE_CRYPTODEV_AESNI_MB_PMD)
2163 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2165 start_cycles = rte_rdtsc_precise();
2166 burst_received = rte_cryptodev_dequeue_burst(
2167 ts_params->dev_id, 0, proc_ops, burst_size);
2168 end_cycles = rte_rdtsc_precise();
2169 total_cycles += end_cycles - start_cycles;
2170 if (burst_received == 0)
2172 num_ops_received += burst_received;
2175 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2176 printf("\t\t%"PRIu64, retries);
2177 printf("\t%"PRIu64, failed_polls);
2178 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2179 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2180 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2184 for (i = 0; i < num_to_submit ; i++) {
2185 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2186 rte_crypto_op_free(c_ops[i]);
2188 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2190 return TEST_SUCCESS;
2194 test_perf_snow3G_vary_burst_size(void)
2196 unsigned total_operations = 4096;
2197 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2198 uint16_t buf_lengths[] = {40};
2201 struct perf_test_params params_set[] = {
2203 .chain = CIPHER_ONLY,
2204 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2205 .cipher_key_length = 16,
2206 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2210 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2211 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2212 .cipher_key_length = 16
2216 printf("\n\nStart %s.", __func__);
2217 printf("\nThis Test measures the average IA cycle cost using a "
2218 "constant request(packet) size. ");
2219 printf("Cycle cost is only valid when indicators show device is not busy,"
2220 " i.e. Retries and EmptyPolls = 0");
2222 for (i = 0; i < RTE_DIM(params_set); i++) {
2224 params_set[i].total_operations = total_operations;
2227 j < RTE_DIM(buf_lengths);
2230 params_set[i].buf_size = buf_lengths[j];
2232 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2241 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2243 uint32_t num_to_submit = pparams->total_operations;
2244 struct rte_crypto_op *c_ops[num_to_submit];
2245 struct rte_crypto_op *proc_ops[num_to_submit];
2246 uint64_t failed_polls, retries, start_cycles,
2247 end_cycles, total_cycles = 0;
2248 uint32_t burst_sent = 0, burst_received = 0;
2249 uint32_t i, burst_size, num_sent, num_ops_received;
2251 struct crypto_testsuite_params *ts_params = &testsuite_params;
2253 static struct rte_cryptodev_sym_session *sess;
2255 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2256 (struct rte_crypto_op *, struct rte_mbuf *,
2257 struct rte_cryptodev_sym_session *,
2258 unsigned int, unsigned int,
2261 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2263 if (rte_cryptodev_count() == 0) {
2264 printf("\nNo crypto devices found. Is PMD build configured?\n");
2268 /* Create Crypto session*/
2269 sess = test_perf_create_openssl_session(ts_params->dev_id,
2270 pparams->chain, pparams->cipher_algo,
2271 pparams->cipher_key_length, pparams->auth_algo);
2272 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2274 /* Generate Crypto op data structure(s)*/
2275 for (i = 0; i < num_to_submit ; i++) {
2276 struct rte_mbuf *m = test_perf_create_pktmbuf(
2279 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2281 struct rte_crypto_op *op =
2282 rte_crypto_op_alloc(ts_params->op_mpool,
2283 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2284 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2286 switch (pparams->cipher_algo) {
2287 case RTE_CRYPTO_CIPHER_3DES_CBC:
2288 case RTE_CRYPTO_CIPHER_3DES_CTR:
2289 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2291 case RTE_CRYPTO_CIPHER_AES_CBC:
2292 case RTE_CRYPTO_CIPHER_AES_CTR:
2293 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2295 case RTE_CRYPTO_CIPHER_AES_GCM:
2296 test_perf_set_crypto_op =
2297 test_perf_set_crypto_op_aes_gcm;
2303 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2304 digest_length, pparams->chain);
2305 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2310 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2311 "auth_algo:%s, Packet Size %u bytes",
2312 pmd_name(gbl_cryptodev_perftest_devtype),
2313 ts_params->dev_id, 0,
2314 chain_mode_name(pparams->chain),
2315 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2316 pparams->cipher_key_length,
2317 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2319 printf("\nOps Tx\tOps Rx\tOps/burst ");
2320 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2323 for (i = 2; i <= 128 ; i *= 2) {
2325 num_ops_received = 0;
2330 while (num_sent < num_to_submit) {
2331 start_cycles = rte_rdtsc_precise();
2332 burst_sent = rte_cryptodev_enqueue_burst(
2334 0, &c_ops[num_sent],
2335 ((num_to_submit - num_sent) <
2337 num_to_submit - num_sent : burst_size);
2338 end_cycles = rte_rdtsc_precise();
2339 if (burst_sent == 0)
2341 num_sent += burst_sent;
2342 total_cycles += (end_cycles - start_cycles);
2344 /* Wait until requests have been sent. */
2347 start_cycles = rte_rdtsc_precise();
2348 burst_received = rte_cryptodev_dequeue_burst(
2349 ts_params->dev_id, 0, proc_ops,
2351 end_cycles = rte_rdtsc_precise();
2352 if (burst_received < burst_sent)
2354 num_ops_received += burst_received;
2356 total_cycles += end_cycles - start_cycles;
2359 while (num_ops_received != num_to_submit) {
2360 /* Sending 0 length burst to flush sw crypto device */
2361 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2364 start_cycles = rte_rdtsc_precise();
2365 burst_received = rte_cryptodev_dequeue_burst(
2366 ts_params->dev_id, 0, proc_ops,
2368 end_cycles = rte_rdtsc_precise();
2370 total_cycles += end_cycles - start_cycles;
2371 if (burst_received == 0)
2373 num_ops_received += burst_received;
2376 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2377 printf("\t\t%"PRIu64, retries);
2378 printf("\t%"PRIu64, failed_polls);
2379 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2380 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2382 printf("\t\t%"PRIu64,
2384 (num_ops_received * pparams->buf_size));
2388 for (i = 0; i < num_to_submit ; i++) {
2389 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2390 rte_crypto_op_free(c_ops[i]);
2392 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2394 return TEST_SUCCESS;
2398 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2400 uint32_t num_to_submit = pparams->total_operations;
2401 struct rte_crypto_op *c_ops[num_to_submit];
2402 struct rte_crypto_op *proc_ops[num_to_submit];
2403 uint64_t failed_polls, retries, start_cycles, end_cycles,
2405 uint32_t burst_sent = 0, burst_received = 0;
2406 uint32_t i, burst_size, num_sent, num_ops_received;
2409 struct crypto_testsuite_params *ts_params = &testsuite_params;
2411 static struct rte_cryptodev_sym_session *sess;
2413 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2415 if (rte_cryptodev_count() == 0) {
2416 printf("\nNo crypto devices found. Is PMD build configured?\n");
2420 /* Create Crypto session*/
2421 sess = test_perf_create_armv8_session(ts_params->dev_id,
2422 pparams->chain, pparams->cipher_algo,
2423 pparams->cipher_key_length, pparams->auth_algo);
2424 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2426 /* Generate Crypto op data structure(s)*/
2427 for (i = 0; i < num_to_submit ; i++) {
2428 struct rte_mbuf *m = test_perf_create_pktmbuf(
2431 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2433 struct rte_crypto_op *op =
2434 rte_crypto_op_alloc(ts_params->op_mpool,
2435 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2436 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2438 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2439 digest_length, pparams->chain);
2440 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2445 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2446 "auth_algo:%s, Packet Size %u bytes",
2447 pmd_name(gbl_cryptodev_perftest_devtype),
2448 ts_params->dev_id, 0,
2449 chain_mode_name(pparams->chain),
2450 rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2451 pparams->cipher_key_length,
2452 rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2454 printf("\nOps Tx\tOps Rx\tOps/burst ");
2456 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2458 for (i = 2; i <= 128 ; i *= 2) {
2460 num_ops_received = 0;
2465 while (num_sent < num_to_submit) {
2466 if ((num_to_submit - num_sent) < burst_size)
2467 nb_ops = num_to_submit - num_sent;
2469 nb_ops = burst_size;
2471 start_cycles = rte_rdtsc();
2472 burst_sent = rte_cryptodev_enqueue_burst(
2474 0, &c_ops[num_sent],
2476 end_cycles = rte_rdtsc();
2478 if (burst_sent == 0)
2480 num_sent += burst_sent;
2481 total_cycles += (end_cycles - start_cycles);
2483 start_cycles = rte_rdtsc();
2484 burst_received = rte_cryptodev_dequeue_burst(
2485 ts_params->dev_id, 0, proc_ops,
2487 end_cycles = rte_rdtsc();
2488 if (burst_received < burst_sent)
2490 num_ops_received += burst_received;
2492 total_cycles += end_cycles - start_cycles;
2495 while (num_ops_received != num_to_submit) {
2496 /* Sending 0 length burst to flush sw crypto device */
2497 rte_cryptodev_enqueue_burst(
2498 ts_params->dev_id, 0, NULL, 0);
2500 start_cycles = rte_rdtsc();
2501 burst_received = rte_cryptodev_dequeue_burst(
2502 ts_params->dev_id, 0, proc_ops, burst_size);
2503 end_cycles = rte_rdtsc();
2505 total_cycles += end_cycles - start_cycles;
2506 if (burst_received == 0)
2508 num_ops_received += burst_received;
2511 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2512 printf("\t\t%"PRIu64, retries);
2513 printf("\t%"PRIu64, failed_polls);
2514 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2515 printf("\t\t%"PRIu64,
2516 (total_cycles/num_ops_received)*burst_size);
2517 printf("\t\t%"PRIu64,
2518 total_cycles/(num_ops_received*pparams->buf_size));
2522 for (i = 0; i < num_to_submit ; i++) {
2523 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2524 rte_crypto_op_free(c_ops[i]);
2527 return TEST_SUCCESS;
2530 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2533 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2535 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2537 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2539 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2541 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2543 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2545 case RTE_CRYPTO_AUTH_AES_GCM:
2552 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2555 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2557 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2558 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2559 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2560 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2561 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2562 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2563 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2564 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2565 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2566 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2567 case RTE_CRYPTO_AUTH_AES_GCM:
2568 return DIGEST_BYTE_LENGTH_AES_GCM;
2574 static uint8_t aes_key[] = {
2575 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2576 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2577 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2578 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2581 static uint8_t aes_iv[] = {
2582 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2583 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2586 static uint8_t aes_gcm_aad[] = {
2587 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2588 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2591 static uint8_t triple_des_key[] = {
2592 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2593 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2594 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2597 static uint8_t triple_des_iv[] = {
2598 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2601 static uint8_t hmac_sha_key[] = {
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,
2615 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2616 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2617 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2620 static uint8_t snow3g_cipher_key[] = {
2621 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2622 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2625 static uint8_t snow3g_iv[] = {
2626 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2627 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2630 static uint8_t snow3g_hash_key[] = {
2631 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2632 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2635 static struct rte_cryptodev_sym_session *
2636 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2637 enum rte_crypto_cipher_algorithm cipher_algo,
2638 unsigned cipher_key_len,
2639 enum rte_crypto_auth_algorithm auth_algo)
2641 struct rte_crypto_sym_xform cipher_xform = { 0 };
2642 struct rte_crypto_sym_xform auth_xform = { 0 };
2645 /* Setup Cipher Parameters */
2646 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2647 cipher_xform.cipher.algo = cipher_algo;
2648 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2650 cipher_xform.cipher.key.data = aes_key;
2651 cipher_xform.cipher.key.length = cipher_key_len;
2652 if (chain != CIPHER_ONLY) {
2653 /* Setup HMAC Parameters */
2654 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2655 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2656 auth_xform.auth.algo = auth_algo;
2657 auth_xform.auth.key.data = hmac_sha_key;
2658 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2659 auth_xform.auth.digest_length =
2660 get_auth_digest_length(auth_algo);
2664 cipher_xform.next = &auth_xform;
2665 auth_xform.next = NULL;
2666 /* Create Crypto session*/
2667 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2669 auth_xform.next = &cipher_xform;
2670 cipher_xform.next = NULL;
2671 /* Create Crypto session*/
2672 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2674 cipher_xform.next = NULL;
2675 /* Create Crypto session*/
2676 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2682 #define SNOW3G_CIPHER_IV_LENGTH 16
2684 static struct rte_cryptodev_sym_session *
2685 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2686 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2687 enum rte_crypto_auth_algorithm auth_algo)
2689 struct rte_crypto_sym_xform cipher_xform = {0};
2690 struct rte_crypto_sym_xform auth_xform = {0};
2693 /* Setup Cipher Parameters */
2694 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2695 cipher_xform.cipher.algo = cipher_algo;
2696 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2698 cipher_xform.cipher.key.data = snow3g_cipher_key;
2699 cipher_xform.cipher.key.length = cipher_key_len;
2701 /* Setup HMAC Parameters */
2702 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2703 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2704 auth_xform.auth.algo = auth_algo;
2706 auth_xform.auth.add_auth_data_length = SNOW3G_CIPHER_IV_LENGTH;
2707 auth_xform.auth.key.data = snow3g_hash_key;
2708 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2709 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2713 cipher_xform.next = &auth_xform;
2714 auth_xform.next = NULL;
2715 /* Create Crypto session*/
2716 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2718 auth_xform.next = &cipher_xform;
2719 cipher_xform.next = NULL;
2720 /* Create Crypto session*/
2721 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2723 cipher_xform.next = NULL;
2724 /* Create Crypto session*/
2725 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2727 auth_xform.next = NULL;
2728 /* Create Crypto session */
2729 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2735 static struct rte_cryptodev_sym_session *
2736 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2737 enum rte_crypto_cipher_algorithm cipher_algo,
2738 unsigned int cipher_key_len,
2739 enum rte_crypto_auth_algorithm auth_algo)
2741 struct rte_crypto_sym_xform cipher_xform = { 0 };
2742 struct rte_crypto_sym_xform auth_xform = { 0 };
2744 /* Setup Cipher Parameters */
2745 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2746 cipher_xform.cipher.algo = cipher_algo;
2747 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2749 switch (cipher_algo) {
2750 case RTE_CRYPTO_CIPHER_3DES_CBC:
2751 case RTE_CRYPTO_CIPHER_3DES_CTR:
2752 cipher_xform.cipher.key.data = triple_des_key;
2754 case RTE_CRYPTO_CIPHER_AES_CBC:
2755 case RTE_CRYPTO_CIPHER_AES_CTR:
2756 case RTE_CRYPTO_CIPHER_AES_GCM:
2757 cipher_xform.cipher.key.data = aes_key;
2763 cipher_xform.cipher.key.length = cipher_key_len;
2765 /* Setup Auth Parameters */
2766 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2767 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2768 auth_xform.auth.algo = auth_algo;
2770 switch (auth_algo) {
2771 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2772 auth_xform.auth.key.data = hmac_sha_key;
2774 case RTE_CRYPTO_AUTH_AES_GCM:
2775 auth_xform.auth.key.data = NULL;
2781 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2782 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2786 cipher_xform.next = &auth_xform;
2787 auth_xform.next = NULL;
2788 /* Create Crypto session*/
2789 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2791 auth_xform.next = &cipher_xform;
2792 cipher_xform.next = NULL;
2793 /* Create Crypto session*/
2794 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2800 static struct rte_cryptodev_sym_session *
2801 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2802 enum rte_crypto_cipher_algorithm cipher_algo,
2803 unsigned int cipher_key_len,
2804 enum rte_crypto_auth_algorithm auth_algo)
2806 struct rte_crypto_sym_xform cipher_xform = { 0 };
2807 struct rte_crypto_sym_xform auth_xform = { 0 };
2809 /* Setup Cipher Parameters */
2810 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2811 cipher_xform.cipher.algo = cipher_algo;
2813 switch (cipher_algo) {
2814 case RTE_CRYPTO_CIPHER_AES_CBC:
2815 cipher_xform.cipher.key.data = aes_cbc_128_key;
2821 cipher_xform.cipher.key.length = cipher_key_len;
2823 /* Setup Auth Parameters */
2824 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2825 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2826 auth_xform.auth.algo = auth_algo;
2828 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2832 cipher_xform.next = &auth_xform;
2833 auth_xform.next = NULL;
2834 /* Encrypt and hash the result */
2835 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2836 /* Create Crypto session*/
2837 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2839 auth_xform.next = &cipher_xform;
2840 cipher_xform.next = NULL;
2841 /* Hash encrypted message and decrypt */
2842 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2843 /* Create Crypto session*/
2844 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2850 #define AES_CIPHER_IV_LENGTH 16
2851 #define AES_GCM_AAD_LENGTH 16
2852 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
2854 static struct rte_mbuf *
2855 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2857 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2859 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2860 rte_pktmbuf_free(m);
2864 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2869 static inline struct rte_crypto_op *
2870 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2871 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2872 unsigned int digest_len, enum chain_mode chain)
2874 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2875 rte_crypto_op_free(op);
2879 /* Authentication Parameters */
2880 if (chain == CIPHER_ONLY) {
2881 op->sym->auth.digest.data = NULL;
2882 op->sym->auth.digest.phys_addr = 0;
2883 op->sym->auth.digest.length = 0;
2884 op->sym->auth.aad.data = NULL;
2885 op->sym->auth.aad.length = 0;
2886 op->sym->auth.data.offset = 0;
2887 op->sym->auth.data.length = 0;
2889 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2890 uint8_t *, AES_CIPHER_IV_LENGTH + data_len);
2891 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2892 AES_CIPHER_IV_LENGTH + data_len);
2893 op->sym->auth.digest.length = digest_len;
2894 op->sym->auth.data.offset = AES_CIPHER_IV_LENGTH;
2895 op->sym->auth.data.length = data_len;
2899 /* Cipher Parameters */
2900 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
2901 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2902 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2904 rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH);
2906 op->sym->cipher.data.offset = AES_CIPHER_IV_LENGTH;
2907 op->sym->cipher.data.length = data_len;
2914 static inline struct rte_crypto_op *
2915 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2916 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2917 unsigned int digest_len, enum chain_mode chain __rte_unused)
2919 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2920 rte_crypto_op_free(op);
2924 /* Authentication Parameters */
2925 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2926 (m->data_off + data_len);
2927 op->sym->auth.digest.phys_addr =
2928 rte_pktmbuf_mtophys_offset(m, data_len);
2929 op->sym->auth.digest.length = digest_len;
2930 op->sym->auth.aad.data = aes_gcm_aad;
2931 op->sym->auth.aad.length = AES_GCM_AAD_LENGTH;
2933 /* Cipher Parameters */
2934 op->sym->cipher.iv.data = aes_iv;
2935 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2937 /* Data lengths/offsets Parameters */
2938 op->sym->auth.data.offset = 0;
2939 op->sym->auth.data.length = data_len;
2941 op->sym->cipher.data.offset = 0;
2942 op->sym->cipher.data.length = data_len;
2949 static inline struct rte_crypto_op *
2950 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2951 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2952 unsigned digest_len)
2954 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2955 rte_crypto_op_free(op);
2959 /* Authentication Parameters */
2960 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2961 (m->data_off + data_len);
2962 op->sym->auth.digest.phys_addr =
2963 rte_pktmbuf_mtophys_offset(m, data_len);
2964 op->sym->auth.digest.length = digest_len;
2965 op->sym->auth.aad.data = snow3g_iv;
2966 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
2968 /* Cipher Parameters */
2969 op->sym->cipher.iv.data = snow3g_iv;
2970 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2972 /* Data lengths/offsets Parameters */
2973 op->sym->auth.data.offset = 0;
2974 op->sym->auth.data.length = data_len << 3;
2976 op->sym->cipher.data.offset = 0;
2977 op->sym->cipher.data.length = data_len << 3;
2984 static inline struct rte_crypto_op *
2985 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2987 struct rte_cryptodev_sym_session *sess,
2990 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2991 rte_crypto_op_free(op);
2995 /* Cipher Parameters */
2996 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
2997 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2998 rte_memcpy(op->sym->cipher.iv.data, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2999 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
3001 op->sym->cipher.data.offset = SNOW3G_CIPHER_IV_LENGTH;
3002 op->sym->cipher.data.length = data_len << 3;
3010 static inline struct rte_crypto_op *
3011 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3013 struct rte_cryptodev_sym_session *sess,
3015 unsigned digest_len)
3017 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3018 rte_crypto_op_free(op);
3022 /* Authentication Parameters */
3024 op->sym->auth.digest.data =
3025 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3027 op->sym->auth.digest.phys_addr =
3028 rte_pktmbuf_mtophys_offset(m, data_len +
3029 SNOW3G_CIPHER_IV_LENGTH);
3030 op->sym->auth.digest.length = digest_len;
3031 op->sym->auth.aad.data = rte_pktmbuf_mtod(m, uint8_t *);
3032 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
3033 rte_memcpy(op->sym->auth.aad.data, snow3g_iv,
3034 SNOW3G_CIPHER_IV_LENGTH);
3035 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
3037 /* Data lengths/offsets Parameters */
3038 op->sym->auth.data.offset = SNOW3G_CIPHER_IV_LENGTH;
3039 op->sym->auth.data.length = data_len << 3;
3047 static inline struct rte_crypto_op *
3048 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3049 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3050 unsigned int digest_len, enum chain_mode chain __rte_unused)
3052 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3053 rte_crypto_op_free(op);
3057 /* Authentication Parameters */
3058 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3059 (m->data_off + data_len);
3060 op->sym->auth.digest.phys_addr =
3061 rte_pktmbuf_mtophys_offset(m, data_len);
3062 op->sym->auth.digest.length = digest_len;
3064 /* Cipher Parameters */
3065 op->sym->cipher.iv.data = triple_des_iv;
3066 op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
3068 /* Data lengths/offsets Parameters */
3069 op->sym->auth.data.offset = 0;
3070 op->sym->auth.data.length = data_len;
3072 op->sym->cipher.data.offset = 0;
3073 op->sym->cipher.data.length = data_len;
3080 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3081 * same time, i.e. as they're not dereferenced there's no need to wait until
3082 * finished with to re-use */
3083 #define NUM_MBUF_SETS 8
3086 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3087 struct perf_test_params *pparams)
3089 uint16_t i, k, l, m;
3091 uint16_t ops_unused = 0;
3093 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3094 uint64_t processed = 0, failed_polls = 0, retries = 0;
3095 uint64_t tsc_start = 0, tsc_end = 0;
3097 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3099 struct rte_crypto_op *ops[pparams->burst_size];
3100 struct rte_crypto_op *proc_ops[pparams->burst_size];
3102 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3104 struct crypto_testsuite_params *ts_params = &testsuite_params;
3106 static struct rte_cryptodev_sym_session *sess;
3108 if (rte_cryptodev_count() == 0) {
3109 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3113 /* Create Crypto session*/
3114 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3115 pparams->chain, pparams->cipher_algo,
3116 pparams->cipher_key_length, pparams->auth_algo);
3117 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3119 /* Generate a burst of crypto operations */
3120 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3121 mbufs[i] = test_perf_create_pktmbuf(
3125 if (mbufs[i] == NULL) {
3126 printf("\nFailed to get mbuf - freeing the rest.\n");
3127 for (k = 0; k < i; k++)
3128 rte_pktmbuf_free(mbufs[k]);
3132 /* Make room for Digest and IV in mbuf */
3133 if (pparams->chain != CIPHER_ONLY)
3134 rte_pktmbuf_append(mbufs[i], digest_length);
3135 rte_pktmbuf_prepend(mbufs[i], AES_CIPHER_IV_LENGTH);
3139 tsc_start = rte_rdtsc_precise();
3141 while (total_enqueued < pparams->total_operations) {
3142 uint16_t burst_size =
3143 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3144 pparams->burst_size : pparams->total_operations-total_enqueued;
3145 uint16_t ops_needed = burst_size-ops_unused;
3147 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3148 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3149 printf("\nFailed to alloc enough ops, finish dequeuing "
3150 "and free ops below.");
3152 for (i = 0; i < ops_needed; i++)
3153 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3154 mbufs[i + (pparams->burst_size *
3155 (j % NUM_MBUF_SETS))],
3156 sess, pparams->buf_size, digest_length,
3160 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3161 queue_id, ops, burst_size);
3163 if (burst_enqueued < burst_size)
3166 ops_unused = burst_size-burst_enqueued;
3167 total_enqueued += burst_enqueued;
3171 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3172 proc_ops, pparams->burst_size);
3173 if (burst_dequeued == 0)
3176 processed += burst_dequeued;
3178 for (l = 0; l < burst_dequeued; l++)
3179 rte_crypto_op_free(proc_ops[l]);
3184 /* Dequeue any operations still in the crypto device */
3185 while (processed < pparams->total_operations) {
3186 /* Sending 0 length burst to flush sw crypto device */
3187 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3190 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3191 proc_ops, pparams->burst_size);
3192 if (burst_dequeued == 0)
3195 processed += burst_dequeued;
3197 for (m = 0; m < burst_dequeued; m++)
3198 rte_crypto_op_free(proc_ops[m]);
3202 tsc_end = rte_rdtsc_precise();
3204 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3205 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3207 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3208 throughput, retries, failed_polls);
3210 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3211 rte_pktmbuf_free(mbufs[i]);
3212 rte_cryptodev_sym_session_free(dev_id, sess);
3215 return TEST_SUCCESS;
3220 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3221 struct perf_test_params *pparams)
3223 uint16_t i, k, l, m;
3225 uint16_t ops_unused = 0;
3226 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3227 uint64_t processed = 0, failed_polls = 0, retries = 0;
3228 uint64_t tsc_start = 0, tsc_end = 0;
3230 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3232 struct rte_crypto_op *ops[pparams->burst_size];
3233 struct rte_crypto_op *proc_ops[pparams->burst_size];
3235 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3237 struct crypto_testsuite_params *ts_params = &testsuite_params;
3239 static struct rte_cryptodev_sym_session *sess;
3241 if (rte_cryptodev_count() == 0) {
3242 printf("\nNo crypto devices found. Is PMD build configured?\n");
3243 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3247 /* Create Crypto session*/
3248 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3249 pparams->chain, pparams->cipher_algo,
3250 pparams->cipher_key_length, pparams->auth_algo);
3251 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3253 /* Generate a burst of crypto operations */
3254 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3256 * Buffer size + iv/aad len is allocated, for perf tests they
3257 * are equal + digest len.
3259 mbufs[i] = test_perf_create_pktmbuf(
3261 pparams->buf_size + SNOW3G_CIPHER_IV_LENGTH +
3264 if (mbufs[i] == NULL) {
3265 printf("\nFailed to get mbuf - freeing the rest.\n");
3266 for (k = 0; k < i; k++)
3267 rte_pktmbuf_free(mbufs[k]);
3273 tsc_start = rte_rdtsc_precise();
3275 while (total_enqueued < pparams->total_operations) {
3276 uint16_t burst_size =
3277 (total_enqueued+pparams->burst_size)
3278 <= pparams->total_operations ?
3279 pparams->burst_size : pparams->total_operations-total_enqueued;
3280 uint16_t ops_needed = burst_size-ops_unused;
3281 /* Handle the last burst correctly */
3282 uint16_t op_offset = pparams->burst_size - burst_size;
3285 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3286 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3287 ops+op_offset, ops_needed)) {
3288 printf("\nFailed to alloc enough ops.");
3289 /*Don't exit, dequeue, more ops should become available*/
3291 for (i = 0; i < ops_needed; i++) {
3292 if (pparams->chain == HASH_ONLY)
3294 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3296 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3298 pparams->buf_size, digest_length);
3299 else if (pparams->chain == CIPHER_ONLY)
3301 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3303 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3312 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3313 ops+op_offset, burst_size);
3315 if (burst_enqueued < burst_size)
3318 ops_unused = burst_size-burst_enqueued;
3319 total_enqueued += burst_enqueued;
3323 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3324 proc_ops, pparams->burst_size);
3325 if (burst_dequeued == 0) {
3328 processed += burst_dequeued;
3329 for (l = 0; l < burst_dequeued; l++)
3330 rte_crypto_op_free(proc_ops[l]);
3335 /* Dequeue any operations still in the crypto device */
3336 while (processed < pparams->total_operations) {
3337 /* Sending 0 length burst to flush sw crypto device */
3338 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3341 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3342 proc_ops, pparams->burst_size);
3343 if (burst_dequeued == 0)
3346 processed += burst_dequeued;
3347 for (m = 0; m < burst_dequeued; m++)
3348 rte_crypto_op_free(proc_ops[m]);
3352 tsc_end = rte_rdtsc_precise();
3354 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3355 double cycles_burst = (double) (tsc_end - tsc_start) /
3356 (double) processed * pparams->burst_size;
3357 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3358 double cycles_B = cycles_buff / pparams->buf_size;
3359 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3361 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3362 /* Cycle count misleading on HW devices for this test, so don't print */
3363 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3364 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3365 pparams->buf_size, ops_s/1000000,
3366 throughput, retries, failed_polls);
3368 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3369 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3370 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3371 cycles_buff, cycles_B, retries, failed_polls);
3374 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3375 rte_pktmbuf_free(mbufs[i]);
3376 rte_cryptodev_sym_session_free(dev_id, sess);
3379 return TEST_SUCCESS;
3383 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3384 struct perf_test_params *pparams)
3386 uint16_t i, k, l, m;
3388 uint16_t ops_unused = 0;
3390 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3391 uint64_t processed = 0, failed_polls = 0, retries = 0;
3392 uint64_t tsc_start = 0, tsc_end = 0;
3394 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3396 struct rte_crypto_op *ops[pparams->burst_size];
3397 struct rte_crypto_op *proc_ops[pparams->burst_size];
3399 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3401 struct crypto_testsuite_params *ts_params = &testsuite_params;
3403 static struct rte_cryptodev_sym_session *sess;
3405 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3406 (struct rte_crypto_op *, struct rte_mbuf *,
3407 struct rte_cryptodev_sym_session *,
3408 unsigned int, unsigned int,
3411 switch (pparams->cipher_algo) {
3412 case RTE_CRYPTO_CIPHER_3DES_CBC:
3413 case RTE_CRYPTO_CIPHER_3DES_CTR:
3414 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3416 case RTE_CRYPTO_CIPHER_AES_CBC:
3417 case RTE_CRYPTO_CIPHER_AES_CTR:
3418 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3420 case RTE_CRYPTO_CIPHER_AES_GCM:
3421 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3427 if (rte_cryptodev_count() == 0) {
3428 printf("\nNo crypto devices found. Is PMD build configured?\n");
3432 /* Create Crypto session*/
3433 sess = test_perf_create_openssl_session(ts_params->dev_id,
3434 pparams->chain, pparams->cipher_algo,
3435 pparams->cipher_key_length, pparams->auth_algo);
3436 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3438 /* Generate a burst of crypto operations */
3439 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3440 mbufs[i] = test_perf_create_pktmbuf(
3444 if (mbufs[i] == NULL) {
3445 printf("\nFailed to get mbuf - freeing the rest.\n");
3446 for (k = 0; k < i; k++)
3447 rte_pktmbuf_free(mbufs[k]);
3452 tsc_start = rte_rdtsc_precise();
3454 while (total_enqueued < pparams->total_operations) {
3455 uint16_t burst_size =
3456 total_enqueued + pparams->burst_size <=
3457 pparams->total_operations ? pparams->burst_size :
3458 pparams->total_operations - total_enqueued;
3459 uint16_t ops_needed = burst_size - ops_unused;
3461 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3462 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3463 printf("\nFailed to alloc enough ops, finish dequeuing "
3464 "and free ops below.");
3466 for (i = 0; i < ops_needed; i++)
3467 ops[i] = test_perf_set_crypto_op(ops[i],
3468 mbufs[i + (pparams->burst_size *
3469 (j % NUM_MBUF_SETS))],
3470 sess, pparams->buf_size, digest_length,
3474 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3475 queue_id, ops, burst_size);
3477 if (burst_enqueued < burst_size)
3480 ops_unused = burst_size - burst_enqueued;
3481 total_enqueued += burst_enqueued;
3485 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3486 proc_ops, pparams->burst_size);
3487 if (burst_dequeued == 0)
3490 processed += burst_dequeued;
3492 for (l = 0; l < burst_dequeued; l++)
3493 rte_crypto_op_free(proc_ops[l]);
3498 /* Dequeue any operations still in the crypto device */
3499 while (processed < pparams->total_operations) {
3500 /* Sending 0 length burst to flush sw crypto device */
3501 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3504 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3505 proc_ops, pparams->burst_size);
3506 if (burst_dequeued == 0)
3509 processed += burst_dequeued;
3511 for (m = 0; m < burst_dequeued; m++)
3512 rte_crypto_op_free(proc_ops[m]);
3516 tsc_end = rte_rdtsc_precise();
3518 double ops_s = ((double)processed / (tsc_end - tsc_start))
3520 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3523 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3524 ops_s / 1000000, throughput, retries, failed_polls);
3526 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3527 rte_pktmbuf_free(mbufs[i]);
3528 rte_cryptodev_sym_session_free(dev_id, sess);
3531 return TEST_SUCCESS;
3535 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3536 struct perf_test_params *pparams)
3538 uint16_t i, k, l, m;
3540 uint16_t ops_unused = 0;
3541 uint16_t burst_size;
3542 uint16_t ops_needed;
3544 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3545 uint64_t processed = 0, failed_polls = 0, retries = 0;
3546 uint64_t tsc_start = 0, tsc_end = 0;
3548 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3550 struct rte_crypto_op *ops[pparams->burst_size];
3551 struct rte_crypto_op *proc_ops[pparams->burst_size];
3553 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3555 struct crypto_testsuite_params *ts_params = &testsuite_params;
3557 static struct rte_cryptodev_sym_session *sess;
3559 if (rte_cryptodev_count() == 0) {
3560 printf("\nNo crypto devices found. Is PMD build configured?\n");
3564 /* Create Crypto session*/
3565 sess = test_perf_create_armv8_session(ts_params->dev_id,
3566 pparams->chain, pparams->cipher_algo,
3567 pparams->cipher_key_length, pparams->auth_algo);
3568 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3570 /* Generate a burst of crypto operations */
3571 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3572 mbufs[i] = test_perf_create_pktmbuf(
3576 if (mbufs[i] == NULL) {
3577 printf("\nFailed to get mbuf - freeing the rest.\n");
3578 for (k = 0; k < i; k++)
3579 rte_pktmbuf_free(mbufs[k]);
3584 tsc_start = rte_rdtsc();
3586 while (total_enqueued < pparams->total_operations) {
3587 if ((total_enqueued + pparams->burst_size) <=
3588 pparams->total_operations)
3589 burst_size = pparams->burst_size;
3591 burst_size = pparams->total_operations - total_enqueued;
3593 ops_needed = burst_size - ops_unused;
3595 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3596 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3597 printf("\nFailed to alloc enough ops, finish dequeuing "
3598 "and free ops below.");
3600 for (i = 0; i < ops_needed; i++)
3601 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3602 mbufs[i + (pparams->burst_size *
3603 (j % NUM_MBUF_SETS))], sess,
3604 pparams->buf_size, digest_length,
3608 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3609 queue_id, ops, burst_size);
3611 if (burst_enqueued < burst_size)
3614 ops_unused = burst_size - burst_enqueued;
3615 total_enqueued += burst_enqueued;
3619 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3620 proc_ops, pparams->burst_size);
3621 if (burst_dequeued == 0)
3624 processed += burst_dequeued;
3626 for (l = 0; l < burst_dequeued; l++)
3627 rte_crypto_op_free(proc_ops[l]);
3632 /* Dequeue any operations still in the crypto device */
3633 while (processed < pparams->total_operations) {
3634 /* Sending 0 length burst to flush sw crypto device */
3635 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3638 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3639 proc_ops, pparams->burst_size);
3640 if (burst_dequeued == 0)
3643 processed += burst_dequeued;
3645 for (m = 0; m < burst_dequeued; m++)
3646 rte_crypto_op_free(proc_ops[m]);
3650 tsc_end = rte_rdtsc();
3652 double ops_s = ((double)processed / (tsc_end - tsc_start))
3654 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3657 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3658 ops_s / 1000000, throughput, retries, failed_polls);
3660 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3661 rte_pktmbuf_free(mbufs[i]);
3664 return TEST_SUCCESS;
3669 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3670 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3671 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3673 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3674 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3675 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3677 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3678 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3679 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3682 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3684 unsigned total_operations = 1000000;
3685 unsigned burst_size = 32;
3686 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3689 struct perf_test_params params_set[] = {
3691 .chain = CIPHER_ONLY,
3692 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3693 .cipher_key_length = 16,
3694 .auth_algo = RTE_CRYPTO_AUTH_NULL
3697 .chain = CIPHER_HASH,
3698 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3699 .cipher_key_length = 16,
3700 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3703 .chain = CIPHER_HASH,
3705 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3706 .cipher_key_length = 16,
3707 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3710 .chain = CIPHER_HASH,
3712 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3713 .cipher_key_length = 16,
3714 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3717 .chain = CIPHER_HASH,
3719 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3720 .cipher_key_length = 32,
3721 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3724 .chain = CIPHER_HASH,
3726 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3727 .cipher_key_length = 32,
3728 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3731 .chain = CIPHER_HASH,
3733 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3734 .cipher_key_length = 32,
3735 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3739 for (i = 0; i < RTE_DIM(params_set); i++) {
3741 params_set[i].total_operations = total_operations;
3742 params_set[i].burst_size = burst_size;
3743 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3744 " burst_size: %d ops\n",
3745 chain_mode_name(params_set[i].chain),
3746 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3747 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3748 params_set[i].cipher_key_length,
3750 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3751 "Retries\tEmptyPolls\n");
3752 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3753 params_set[i].buf_size = buf_lengths[j];
3754 test_perf_aes_sha(testsuite_params.dev_id, 0,
3762 test_perf_snow3G_vary_pkt_size(void)
3764 unsigned total_operations = 1000000;
3767 uint16_t burst_sizes[] = { 64 };
3768 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3770 struct perf_test_params params_set[] = {
3772 .chain = CIPHER_ONLY,
3773 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3774 .cipher_key_length = 16,
3775 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3779 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3780 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3781 .cipher_key_length = 16
3785 printf("\n\nStart %s.", __func__);
3786 printf("\nTest to measure max throughput at various pkt sizes.");
3787 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3788 " so cycle cost not relevant (n/a displayed).");
3790 for (i = 0; i < RTE_DIM(params_set); i++) {
3792 params_set[i].total_operations = total_operations;
3793 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3794 enum rte_crypto_cipher_algorithm cipher_algo =
3795 params_set[i].cipher_algo;
3796 enum rte_crypto_auth_algorithm auth_algo =
3797 params_set[i].auth_algo;
3798 printf("\nOn %s dev%u qp%u, %s, "
3799 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3800 pmd_name(gbl_cryptodev_perftest_devtype),
3801 testsuite_params.dev_id, 0,
3802 chain_mode_name(params_set[i].chain),
3803 rte_crypto_cipher_algorithm_strings[cipher_algo],
3804 rte_crypto_auth_algorithm_strings[auth_algo],
3807 params_set[i].burst_size = burst_sizes[k];
3808 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3809 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3810 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3812 params_set[i].buf_size = buf_lengths[j];
3814 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3823 test_perf_openssl_vary_pkt_size(void)
3825 unsigned int total_operations = 10000;
3826 unsigned int burst_size = { 64 };
3827 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3831 struct perf_test_params params_set[] = {
3833 .chain = CIPHER_HASH,
3835 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3836 .cipher_key_length = 16,
3837 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3840 .chain = CIPHER_HASH,
3842 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3843 .cipher_key_length = 24,
3844 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3847 .chain = CIPHER_HASH,
3849 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3850 .cipher_key_length = 16,
3851 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3854 .chain = CIPHER_HASH,
3856 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3857 .cipher_key_length = 32,
3858 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3861 .chain = CIPHER_HASH,
3863 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3864 .cipher_key_length = 16,
3865 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3868 .chain = CIPHER_HASH,
3870 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3871 .cipher_key_length = 24,
3872 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3875 .chain = CIPHER_HASH,
3877 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3878 .cipher_key_length = 16,
3879 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3883 for (i = 0; i < RTE_DIM(params_set); i++) {
3884 params_set[i].total_operations = total_operations;
3885 params_set[i].burst_size = burst_size;
3886 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3887 " burst_size: %d ops\n",
3888 chain_mode_name(params_set[i].chain),
3889 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3890 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3891 params_set[i].cipher_key_length,
3893 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3895 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3896 params_set[i].buf_size = buf_lengths[j];
3897 test_perf_openssl(testsuite_params.dev_id, 0,
3906 test_perf_openssl_vary_burst_size(void)
3908 unsigned int total_operations = 4096;
3909 uint16_t buf_lengths[] = { 40 };
3912 struct perf_test_params params_set[] = {
3914 .chain = CIPHER_HASH,
3916 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3917 .cipher_key_length = 16,
3918 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3921 .chain = CIPHER_HASH,
3923 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3924 .cipher_key_length = 24,
3925 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3928 .chain = CIPHER_HASH,
3930 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3931 .cipher_key_length = 16,
3932 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3935 .chain = CIPHER_HASH,
3937 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3938 .cipher_key_length = 32,
3939 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3942 .chain = CIPHER_HASH,
3944 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3945 .cipher_key_length = 16,
3946 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3949 .chain = CIPHER_HASH,
3951 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3952 .cipher_key_length = 24,
3953 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3956 .chain = CIPHER_HASH,
3958 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3959 .cipher_key_length = 16,
3960 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3964 printf("\n\nStart %s.", __func__);
3965 printf("\nThis Test measures the average IA cycle cost using a "
3966 "constant request(packet) size. ");
3967 printf("Cycle cost is only valid when indicators show device is not"
3968 " busy, i.e. Retries and EmptyPolls = 0");
3970 for (i = 0; i < RTE_DIM(params_set); i++) {
3972 params_set[i].total_operations = total_operations;
3974 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3975 params_set[i].buf_size = buf_lengths[j];
3976 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3984 test_perf_armv8_vary_pkt_size(void)
3986 unsigned int total_operations = 100000;
3987 unsigned int burst_size = { 64 };
3988 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3992 struct perf_test_params params_set[] = {
3994 .chain = CIPHER_HASH,
3996 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3997 .cipher_key_length = 16,
3998 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4001 .chain = HASH_CIPHER,
4003 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4004 .cipher_key_length = 16,
4005 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4008 .chain = CIPHER_HASH,
4010 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4011 .cipher_key_length = 16,
4012 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4015 .chain = HASH_CIPHER,
4017 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4018 .cipher_key_length = 16,
4019 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4023 for (i = 0; i < RTE_DIM(params_set); i++) {
4024 params_set[i].total_operations = total_operations;
4025 params_set[i].burst_size = burst_size;
4026 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4027 " burst_size: %d ops\n",
4028 chain_mode_name(params_set[i].chain),
4029 rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4030 rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4031 params_set[i].cipher_key_length,
4033 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4035 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4036 params_set[i].buf_size = buf_lengths[j];
4037 test_perf_armv8(testsuite_params.dev_id, 0,
4046 test_perf_armv8_vary_burst_size(void)
4048 unsigned int total_operations = 4096;
4049 uint16_t buf_lengths[] = { 64 };
4052 struct perf_test_params params_set[] = {
4054 .chain = CIPHER_HASH,
4056 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4057 .cipher_key_length = 16,
4058 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4061 .chain = HASH_CIPHER,
4063 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4064 .cipher_key_length = 16,
4065 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4068 .chain = CIPHER_HASH,
4070 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4071 .cipher_key_length = 16,
4072 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4075 .chain = HASH_CIPHER,
4077 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4078 .cipher_key_length = 16,
4079 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4083 printf("\n\nStart %s.", __func__);
4084 printf("\nThis Test measures the average IA cycle cost using a "
4085 "constant request(packet) size. ");
4086 printf("Cycle cost is only valid when indicators show device is "
4087 "not busy, i.e. Retries and EmptyPolls = 0");
4089 for (i = 0; i < RTE_DIM(params_set); i++) {
4091 params_set[i].total_operations = total_operations;
4093 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4094 params_set[i].buf_size = buf_lengths[j];
4095 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4103 test_perf_aes_cbc_vary_burst_size(void)
4105 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4109 static struct rte_cryptodev_sym_session *
4110 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4112 static struct rte_cryptodev_sym_session *sess;
4113 struct rte_crypto_sym_xform cipher_xform = { 0 };
4114 struct rte_crypto_sym_xform auth_xform = { 0 };
4116 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4117 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4119 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4120 pparams->session_attrs->key_cipher_len);
4121 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4122 pparams->session_attrs->key_auth_len);
4124 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4125 cipher_xform.next = NULL;
4127 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4128 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4129 cipher_xform.cipher.key.data = cipher_key;
4130 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4132 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4133 auth_xform.next = NULL;
4135 auth_xform.auth.op = pparams->session_attrs->auth;
4136 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4138 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4139 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4142 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4143 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4144 cipher_xform.next = &auth_xform;
4145 sess = rte_cryptodev_sym_session_create(dev_id,
4148 auth_xform.next = &cipher_xform;
4149 sess = rte_cryptodev_sym_session_create(dev_id,
4156 static inline struct rte_crypto_op *
4157 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4158 struct rte_cryptodev_sym_session *sess,
4159 struct crypto_params *m_hlp,
4160 struct perf_test_params *params)
4162 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4163 rte_crypto_op_free(op);
4167 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len,
4170 op->sym->auth.digest.data = m_hlp->digest;
4171 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4173 params->symmetric_op->aad_len +
4175 params->symmetric_op->p_len);
4177 op->sym->auth.digest.length = params->symmetric_op->t_len;
4179 op->sym->auth.aad.data = m_hlp->aad;
4180 op->sym->auth.aad.length = params->symmetric_op->aad_len;
4181 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys_offset(
4185 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4186 params->symmetric_op->aad_len);
4188 op->sym->cipher.iv.data = m_hlp->iv;
4189 rte_memcpy(op->sym->cipher.iv.data, params->symmetric_op->iv_data,
4190 params->symmetric_op->iv_len);
4191 if (params->symmetric_op->iv_len == 12)
4192 op->sym->cipher.iv.data[15] = 1;
4194 op->sym->cipher.iv.length = params->symmetric_op->iv_len;
4196 op->sym->auth.data.offset =
4197 iv_pad_len + params->symmetric_op->aad_len;
4198 op->sym->auth.data.length = params->symmetric_op->p_len;
4200 op->sym->cipher.data.offset =
4201 iv_pad_len + params->symmetric_op->aad_len;
4202 op->sym->cipher.data.length = params->symmetric_op->p_len;
4209 static struct rte_mbuf *
4210 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4211 struct perf_test_params *params,
4212 unsigned buf_sz, struct crypto_params *m_hlp)
4214 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4215 uint16_t iv_pad_len =
4216 ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, 16);
4217 uint16_t aad_len = params->symmetric_op->aad_len;
4218 uint16_t digest_size = params->symmetric_op->t_len;
4221 p = rte_pktmbuf_append(m, aad_len);
4223 rte_pktmbuf_free(m);
4226 m_hlp->aad = (uint8_t *)p;
4228 p = rte_pktmbuf_append(m, iv_pad_len);
4230 rte_pktmbuf_free(m);
4233 m_hlp->iv = (uint8_t *)p;
4235 p = rte_pktmbuf_append(m, buf_sz);
4237 rte_pktmbuf_free(m);
4240 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4242 p = rte_pktmbuf_append(m, digest_size);
4244 rte_pktmbuf_free(m);
4247 m_hlp->digest = (uint8_t *)p;
4253 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4254 struct perf_test_params *pparams, uint32_t test_ops)
4257 struct crypto_testsuite_params *ts_params = &testsuite_params;
4258 struct rte_cryptodev_sym_session *sess;
4259 struct rte_crypto_op *ops[pparams->burst_size];
4260 struct rte_crypto_op *proc_ops[pparams->burst_size];
4261 uint32_t total_operations = pparams->total_operations;
4263 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4264 uint64_t processed = 0, failed_polls = 0, retries = 0;
4265 uint64_t tsc_start = 0, tsc_end = 0;
4267 uint16_t i = 0, l = 0, m = 0;
4268 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4269 uint16_t ops_unused = 0;
4271 struct rte_mbuf *mbufs[burst];
4272 struct crypto_params m_hlp[burst];
4274 if (rte_cryptodev_count() == 0) {
4275 printf("\nNo crypto devices available. "
4276 "Is kernel driver loaded?\n");
4280 sess = test_perf_create_session(dev_id, pparams);
4281 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4283 for (i = 0; i < burst; i++) {
4284 mbufs[i] = test_perf_create_pktmbuf_fill(
4286 pparams, pparams->symmetric_op->p_len,
4291 total_operations = test_ops;
4293 tsc_start = rte_rdtsc_precise();
4294 while (total_enqueued < total_operations) {
4295 uint16_t burst_size =
4296 total_enqueued+pparams->burst_size <= total_operations ?
4297 pparams->burst_size : total_operations-total_enqueued;
4298 uint16_t ops_needed = burst_size-ops_unused;
4300 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4301 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4302 printf("\nFailed to alloc enough ops, "
4303 "finish dequeuing");
4305 for (i = 0; i < ops_needed; i++)
4306 ops[i] = perf_gcm_set_crypto_op(ops[i],
4307 mbufs[i + (pparams->burst_size *
4308 (j % NUM_MBUF_SETS))],
4309 sess, &m_hlp[i + (pparams->burst_size *
4310 (j % NUM_MBUF_SETS))], pparams);
4313 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4314 queue_id, ops, burst_size);
4316 if (burst_enqueued < burst_size)
4319 ops_unused = burst_size-burst_enqueued;
4320 total_enqueued += burst_enqueued;
4324 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4325 proc_ops, pparams->burst_size);
4326 if (burst_dequeued == 0)
4329 processed += burst_dequeued;
4331 for (l = 0; l < burst_dequeued; l++)
4332 rte_crypto_op_free(proc_ops[l]);
4338 /* Dequeue any operations still in the crypto device */
4339 while (processed < total_operations) {
4340 /* Sending 0 length burst to flush sw crypto device */
4341 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4344 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4345 proc_ops, pparams->burst_size);
4346 if (burst_dequeued == 0)
4349 processed += burst_dequeued;
4351 for (m = 0; m < burst_dequeued; m++) {
4353 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP
4354 (pparams->symmetric_op->iv_len, 16);
4355 uint8_t *pkt = rte_pktmbuf_mtod(
4356 proc_ops[m]->sym->m_src,
4359 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4360 pparams->symmetric_op->c_data,
4362 pparams->symmetric_op->aad_len,
4363 pparams->symmetric_op->c_len,
4364 "GCM Ciphertext data not as expected");
4366 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4367 pparams->symmetric_op->t_data,
4369 pparams->symmetric_op->aad_len +
4370 pparams->symmetric_op->c_len,
4371 pparams->symmetric_op->t_len,
4372 "GCM MAC data not as expected");
4375 rte_crypto_op_free(proc_ops[m]);
4380 tsc_end = rte_rdtsc_precise();
4382 double ops_s = ((double)processed / (tsc_end - tsc_start))
4384 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4388 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4389 pparams->symmetric_op->p_len,
4390 ops_s/1000000, throughput, retries, failed_polls);
4393 for (i = 0; i < burst; i++)
4394 rte_pktmbuf_free(mbufs[i]);
4395 rte_cryptodev_sym_session_free(dev_id, sess);
4401 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4403 uint16_t i, j, k, loops = 1;
4405 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4407 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4408 &AES_GCM_128_12IV_0AAD
4411 if (continual_buf_len)
4412 loops = continual_size;
4414 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4416 const unsigned burst_size = 32;
4418 struct symmetric_op ops_set[TEST_CASES_GCM];
4419 struct perf_test_params params_set[TEST_CASES_GCM];
4420 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4421 static const struct cryptodev_perf_test_data *gcm_test;
4423 for (i = 0; i < TEST_CASES_GCM; ++i) {
4425 gcm_test = gcm_tests[i];
4427 session_attrs[i].cipher =
4428 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4429 session_attrs[i].cipher_algorithm =
4430 RTE_CRYPTO_CIPHER_AES_GCM;
4431 session_attrs[i].key_cipher_data =
4433 session_attrs[i].key_cipher_len =
4435 session_attrs[i].auth_algorithm =
4436 RTE_CRYPTO_AUTH_AES_GCM;
4437 session_attrs[i].auth =
4438 RTE_CRYPTO_AUTH_OP_GENERATE;
4439 session_attrs[i].key_auth_data = NULL;
4440 session_attrs[i].key_auth_len = 0;
4441 session_attrs[i].digest_len =
4442 gcm_test->auth_tag.len;
4444 ops_set[i].aad_data = gcm_test->aad.data;
4445 ops_set[i].aad_len = gcm_test->aad.len;
4446 ops_set[i].iv_data = gcm_test->iv.data;
4447 ops_set[i].iv_len = gcm_test->iv.len;
4448 ops_set[i].p_data = gcm_test->plaintext.data;
4449 ops_set[i].p_len = buf_lengths[i];
4450 ops_set[i].c_data = gcm_test->ciphertext.data;
4451 ops_set[i].c_len = buf_lengths[i];
4452 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4453 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4455 params_set[i].chain = CIPHER_HASH;
4456 params_set[i].session_attrs = &session_attrs[i];
4457 params_set[i].symmetric_op = &ops_set[i];
4458 if (continual_buf_len)
4459 params_set[i].total_operations = 0xFFFFFF;
4461 params_set[i].total_operations = 1000000;
4463 params_set[i].burst_size = burst_size;
4467 if (continual_buf_len)
4468 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4469 " burst size: %u", "AES_GCM", "AES_GCM",
4470 gcm_test->key.len << 3, burst_size);
4472 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4474 if (!continual_buf_len) {
4475 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4476 " burst size: %u", "AES_GCM", "AES_GCM",
4477 gcm_test->key.len << 3, burst_size);
4478 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4479 " Retries\tEmptyPolls");
4482 uint16_t len = RTE_DIM(buf_lengths);
4485 if (continual_buf_len) {
4486 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4487 if (buf_lengths[k] == continual_buf_len) {
4493 for (j = p; j < len; ++j) {
4495 params_set[i].symmetric_op->c_len = buf_lengths[j];
4496 params_set[i].symmetric_op->p_len = buf_lengths[j];
4498 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4499 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4501 /* Run is twice, one for encryption/hash checks,
4504 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4508 for (k = 0; k < loops; k++) {
4509 if (continual_buf_len)
4510 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4511 "Throughput(Gbps)\t"
4512 "Retries\tEmptyPolls");
4513 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4516 if (continual_buf_len)
4517 printf("\n\nCompleted loop %i of %i ...",
4527 static int test_cryptodev_perf_AES_GCM(void)
4529 return test_perf_AES_GCM(0, 0);
4532 * This function calls AES GCM performance tests providing
4533 * size of packet as an argument. If size of packet is not
4534 * in the buf_lengths array, all sizes will be used
4536 static int test_continual_perf_AES_GCM(void)
4538 return test_perf_AES_GCM(1024, 10);
4542 test_perf_continual_performance_test(void)
4544 unsigned int total_operations = 0xFFFFFF;
4545 unsigned int total_loops = 10;
4546 unsigned int burst_size = 32;
4549 struct perf_test_params params_set = {
4550 .total_operations = total_operations,
4551 .burst_size = burst_size,
4554 .chain = CIPHER_HASH,
4556 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4557 .cipher_key_length = 16,
4558 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4561 for (i = 1; i <= total_loops; ++i) {
4562 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4563 " burst_size: %d ops\n",
4564 chain_mode_name(params_set.chain),
4565 rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4566 rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4567 params_set.cipher_key_length,
4569 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4570 "Retries\tEmptyPolls\n");
4571 test_perf_aes_sha(testsuite_params.dev_id, 0,
4573 printf("\nCompleted loop %i of %i ...", i, total_loops);
4578 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4579 .suite_name = "Crypto Device Continual Performance Test",
4580 .setup = testsuite_setup,
4581 .teardown = testsuite_teardown,
4582 .unit_test_cases = {
4583 TEST_CASE_ST(ut_setup, ut_teardown,
4584 test_perf_continual_performance_test),
4585 TEST_CASE_ST(ut_setup, ut_teardown,
4586 test_continual_perf_AES_GCM),
4587 TEST_CASES_END() /**< NULL terminate unit test array */
4591 static struct unit_test_suite cryptodev_testsuite = {
4592 .suite_name = "Crypto Device Unit Test Suite",
4593 .setup = testsuite_setup,
4594 .teardown = testsuite_teardown,
4595 .unit_test_cases = {
4596 TEST_CASE_ST(ut_setup, ut_teardown,
4597 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4598 TEST_CASE_ST(ut_setup, ut_teardown,
4599 test_cryptodev_perf_AES_GCM),
4600 TEST_CASE_ST(ut_setup, ut_teardown,
4601 test_perf_aes_cbc_vary_burst_size),
4602 TEST_CASES_END() /**< NULL terminate unit test array */
4606 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4607 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4608 .setup = testsuite_setup,
4609 .teardown = testsuite_teardown,
4610 .unit_test_cases = {
4611 TEST_CASE_ST(ut_setup, ut_teardown,
4612 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4613 TEST_CASES_END() /**< NULL terminate unit test array */
4617 static struct unit_test_suite cryptodev_gcm_testsuite = {
4618 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4619 .setup = testsuite_setup,
4620 .teardown = testsuite_teardown,
4621 .unit_test_cases = {
4622 TEST_CASE_ST(ut_setup, ut_teardown,
4623 test_cryptodev_perf_AES_GCM),
4624 TEST_CASES_END() /**< NULL terminate unit test array */
4628 static struct unit_test_suite cryptodev_aes_testsuite = {
4629 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4630 .setup = testsuite_setup,
4631 .teardown = testsuite_teardown,
4632 .unit_test_cases = {
4633 TEST_CASE_ST(ut_setup, ut_teardown,
4634 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4635 TEST_CASES_END() /**< NULL terminate unit test array */
4639 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4640 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4641 .setup = testsuite_setup,
4642 .teardown = testsuite_teardown,
4643 .unit_test_cases = {
4644 TEST_CASE_ST(ut_setup, ut_teardown,
4645 test_perf_snow3G_vary_pkt_size),
4646 TEST_CASE_ST(ut_setup, ut_teardown,
4647 test_perf_snow3G_vary_burst_size),
4648 TEST_CASES_END() /**< NULL terminate unit test array */
4652 static struct unit_test_suite cryptodev_openssl_testsuite = {
4653 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4654 .setup = testsuite_setup,
4655 .teardown = testsuite_teardown,
4656 .unit_test_cases = {
4657 TEST_CASE_ST(ut_setup, ut_teardown,
4658 test_perf_openssl_vary_pkt_size),
4659 TEST_CASE_ST(ut_setup, ut_teardown,
4660 test_perf_openssl_vary_burst_size),
4661 TEST_CASES_END() /**< NULL terminate unit test array */
4665 static struct unit_test_suite cryptodev_armv8_testsuite = {
4666 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4667 .setup = testsuite_setup,
4668 .teardown = testsuite_teardown,
4669 .unit_test_cases = {
4670 TEST_CASE_ST(ut_setup, ut_teardown,
4671 test_perf_armv8_vary_pkt_size),
4672 TEST_CASE_ST(ut_setup, ut_teardown,
4673 test_perf_armv8_vary_burst_size),
4674 TEST_CASES_END() /**< NULL terminate unit test array */
4679 perftest_aesni_gcm_cryptodev(void)
4681 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4683 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4687 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4689 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4691 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4695 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4697 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4699 return unit_test_suite_runner(&cryptodev_testsuite);
4703 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4705 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4707 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4711 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4713 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4715 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4719 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4721 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4723 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4727 perftest_qat_continual_cryptodev(void)
4729 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4731 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4735 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4737 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4739 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4743 perftest_dpaa2_sec_cryptodev(void)
4745 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4747 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4750 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4751 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4752 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4753 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4754 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4755 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4756 perftest_openssl_cryptodev);
4757 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4758 perftest_qat_continual_cryptodev);
4759 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4760 perftest_sw_armv8_cryptodev);
4761 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4762 perftest_dpaa2_sec_cryptodev);