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 const char *cipher_algo_name(enum rte_crypto_cipher_algorithm cipher_algo)
219 switch (cipher_algo) {
220 case RTE_CRYPTO_CIPHER_NULL: return "NULL";
221 case RTE_CRYPTO_CIPHER_3DES_CBC: return "3DES_CBC";
222 case RTE_CRYPTO_CIPHER_3DES_CTR: return "3DES_CTR";
223 case RTE_CRYPTO_CIPHER_3DES_ECB: return "3DES_ECB";
224 case RTE_CRYPTO_CIPHER_AES_CBC: return "AES_CBC";
225 case RTE_CRYPTO_CIPHER_AES_CCM: return "AES_CCM";
226 case RTE_CRYPTO_CIPHER_AES_CTR: return "AES_CTR";
227 case RTE_CRYPTO_CIPHER_AES_ECB: return "AES_ECB";
228 case RTE_CRYPTO_CIPHER_AES_F8: return "AES_F8";
229 case RTE_CRYPTO_CIPHER_AES_GCM: return "AES_GCM";
230 case RTE_CRYPTO_CIPHER_AES_XTS: return "AES_XTS";
231 case RTE_CRYPTO_CIPHER_ARC4: return "ARC4";
232 case RTE_CRYPTO_CIPHER_KASUMI_F8: return "KASUMI_F8";
233 case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: return "SNOW3G_UEA2";
234 case RTE_CRYPTO_CIPHER_ZUC_EEA3: return "ZUC_EEA3";
235 default: return "Another cipher algo";
239 static const char *auth_algo_name(enum rte_crypto_auth_algorithm auth_algo)
242 case RTE_CRYPTO_AUTH_NULL: return "NULL"; break;
243 case RTE_CRYPTO_AUTH_AES_CBC_MAC: return "AES_CBC_MAC"; break;
244 case RTE_CRYPTO_AUTH_AES_CCM: return "AES_CCM"; break;
245 case RTE_CRYPTO_AUTH_AES_CMAC: return "AES_CMAC,"; break;
246 case RTE_CRYPTO_AUTH_AES_GCM: return "AES_GCM"; break;
247 case RTE_CRYPTO_AUTH_AES_GMAC: return "AES_GMAC"; break;
248 case RTE_CRYPTO_AUTH_AES_XCBC_MAC: return "AES_XCBC_MAC"; break;
249 case RTE_CRYPTO_AUTH_KASUMI_F9: return "KASUMI_F9"; break;
250 case RTE_CRYPTO_AUTH_MD5: return "MD5"; break;
251 case RTE_CRYPTO_AUTH_MD5_HMAC: return "MD5_HMAC,"; break;
252 case RTE_CRYPTO_AUTH_SHA1: return "SHA1"; break;
253 case RTE_CRYPTO_AUTH_SHA1_HMAC: return "SHA1_HMAC"; break;
254 case RTE_CRYPTO_AUTH_SHA224: return "SHA224"; break;
255 case RTE_CRYPTO_AUTH_SHA224_HMAC: return "SHA224_HMAC"; break;
256 case RTE_CRYPTO_AUTH_SHA256: return "SHA256"; break;
257 case RTE_CRYPTO_AUTH_SHA256_HMAC: return "SHA256_HMAC"; break;
258 case RTE_CRYPTO_AUTH_SHA384: return "SHA384,"; break;
259 case RTE_CRYPTO_AUTH_SHA384_HMAC: return "SHA384_HMAC,"; break;
260 case RTE_CRYPTO_AUTH_SHA512: return "SHA512,"; break;
261 case RTE_CRYPTO_AUTH_SHA512_HMAC: return "SHA512_HMAC,"; break;
262 case RTE_CRYPTO_AUTH_SNOW3G_UIA2: return "SNOW3G_UIA2"; break;
263 case RTE_CRYPTO_AUTH_ZUC_EIA3: return "RTE_CRYPTO_AUTH_ZUC_EIA3"; break;
264 default: return "Another auth algo"; break;
268 static struct rte_mbuf *
269 setup_test_string(struct rte_mempool *mpool,
270 const uint8_t *data, size_t len, uint8_t blocksize)
272 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
273 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
276 char *dst = rte_pktmbuf_append(m, t_len);
283 rte_memcpy(dst, (const void *)data, t_len);
288 static struct crypto_testsuite_params testsuite_params = { NULL };
289 static struct crypto_unittest_params unittest_params;
290 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
293 testsuite_setup(void)
295 struct crypto_testsuite_params *ts_params = &testsuite_params;
296 struct rte_cryptodev_info info;
297 unsigned i, nb_devs, valid_dev_id = 0;
301 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
302 if (ts_params->mbuf_mp == NULL) {
303 /* Not already created so create */
304 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
305 "CRYPTO_PERF_MBUFPOOL",
306 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
308 if (ts_params->mbuf_mp == NULL) {
309 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
315 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
316 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
317 NUM_MBUFS, MBUF_CACHE_SIZE,
319 sizeof(struct rte_crypto_sym_xform),
321 if (ts_params->op_mpool == NULL) {
322 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
326 /* Create an AESNI MB device if required */
327 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_MB_PMD) {
328 #ifndef RTE_LIBRTE_PMD_AESNI_MB
329 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
330 " enabled in config file to run this testsuite.\n");
333 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD);
336 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
338 TEST_ASSERT(ret == 0,
339 "Failed to create instance of pmd : %s",
340 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
344 /* Create an AESNI GCM device if required */
345 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_GCM_PMD) {
346 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
347 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
348 " enabled in config file to run this testsuite.\n");
351 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD);
354 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
356 TEST_ASSERT(ret == 0,
357 "Failed to create instance of pmd : %s",
358 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
362 /* Create a SNOW3G device if required */
363 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_SNOW3G_PMD) {
364 #ifndef RTE_LIBRTE_PMD_SNOW3G
365 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
366 " enabled in config file to run this testsuite.\n");
369 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
372 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
374 TEST_ASSERT(ret == 0,
375 "Failed to create instance of pmd : %s",
376 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
380 /* Create an OPENSSL device if required */
381 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_OPENSSL_PMD) {
382 #ifndef RTE_LIBRTE_PMD_OPENSSL
383 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
384 " enabled in config file to run this testsuite.\n");
387 nb_devs = rte_cryptodev_count_devtype(
388 RTE_CRYPTODEV_OPENSSL_PMD);
391 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
394 TEST_ASSERT(ret == 0, "Failed to create "
395 "instance of pmd : %s",
396 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
400 /* Create an ARMv8 device if required */
401 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_ARMV8_PMD) {
402 #ifndef RTE_LIBRTE_PMD_ARMV8_CRYPTO
403 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_ARMV8_CRYPTO must be"
404 " enabled in config file to run this testsuite.\n");
407 nb_devs = rte_cryptodev_count_devtype(
408 RTE_CRYPTODEV_ARMV8_PMD);
411 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
414 TEST_ASSERT(ret == 0, "Failed to create "
415 "instance of pmd : %s",
416 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
420 #ifndef RTE_LIBRTE_PMD_QAT
421 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
422 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
423 "in config file to run this testsuite.\n");
428 nb_devs = rte_cryptodev_count();
430 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
434 /* Search for the first valid */
435 for (i = 0; i < nb_devs; i++) {
436 rte_cryptodev_info_get(i, &info);
437 if (info.dev_type == gbl_cryptodev_perftest_devtype) {
438 ts_params->dev_id = i;
448 * Using Crypto Device Id 0 by default.
449 * Set up all the qps on this device
452 rte_cryptodev_info_get(ts_params->dev_id, &info);
454 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
455 ts_params->conf.socket_id = SOCKET_ID_ANY;
456 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
458 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
460 "Failed to configure cryptodev %u",
463 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
464 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
466 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
467 ts_params->dev_id, qp_id,
469 rte_cryptodev_socket_id(ts_params->dev_id)),
470 "Failed to setup queue pair %u on cryptodev %u",
471 qp_id, ts_params->dev_id);
477 testsuite_teardown(void)
479 struct crypto_testsuite_params *ts_params =
482 if (ts_params->mbuf_mp != NULL)
483 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
484 rte_mempool_avail_count(ts_params->mbuf_mp));
485 if (ts_params->op_mpool != NULL)
486 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
487 rte_mempool_avail_count(ts_params->op_mpool));
493 struct crypto_testsuite_params *ts_params = &testsuite_params;
494 struct crypto_unittest_params *ut_params = &unittest_params;
496 /* Clear unit test parameters before running test */
497 memset(ut_params, 0, sizeof(*ut_params));
499 rte_cryptodev_stats_reset(ts_params->dev_id);
501 /* Start the device */
502 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
503 "Failed to start cryptodev %u",
512 struct crypto_testsuite_params *ts_params = &testsuite_params;
513 struct crypto_unittest_params *ut_params = &unittest_params;
514 struct rte_cryptodev_stats stats;
518 /* free crypto session structure */
520 rte_cryptodev_sym_session_free(ts_params->dev_id,
523 /* free crypto operation structure */
525 rte_crypto_op_free(ut_params->op);
527 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
528 if (ut_params->obuf[i])
529 rte_pktmbuf_free(ut_params->obuf[i]);
530 else if (ut_params->ibuf[i])
531 rte_pktmbuf_free(ut_params->ibuf[i]);
534 if (ts_params->mbuf_mp != NULL)
535 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
536 rte_mempool_avail_count(ts_params->mbuf_mp));
538 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
540 /* Stop the device */
541 rte_cryptodev_stop(ts_params->dev_id);
544 const char plaintext_quote[] =
545 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
546 "Marseilles--The Arrival. On the 24th of February, 1815, the "
547 "look-out at Notre-Dame de la Garde signalled the three-master,"
548 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
549 "pilot put off immediately, and rounding the Chateau d'If, got "
550 "on board the vessel between Cape Morgion and Rion island. "
551 "Immediately, and according to custom, the ramparts of Fort "
552 "Saint-Jean were covered with spectators; it is always an event "
553 "at Marseilles for a ship to come into port, especially when "
554 "this ship, like the Pharaon, has been built, rigged, and laden"
555 " at the old Phocee docks, and belongs to an owner of the city."
556 " The ship drew on and had safely passed the strait, which some"
557 " volcanic shock has made between the Calasareigne and Jaros "
558 "islands; had doubled Pomegue, and approached the harbor under"
559 " topsails, jib, and spanker, but so slowly and sedately that"
560 " the idlers, with that instinct which is the forerunner of "
561 "evil, asked one another what misfortune could have happened "
562 "on board. However, those experienced in navigation saw plainly"
563 " that if any accident had occurred, it was not to the vessel "
564 "herself, for she bore down with all the evidence of being "
565 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
566 "already eased off, and standing by the side of the pilot, who"
567 " was steering the Pharaon towards the narrow entrance of the"
568 " inner port, was a young man, who, with activity and vigilant"
569 " eye, watched every motion of the ship, and repeated each "
570 "direction of the pilot. The vague disquietude which prevailed "
571 "among the spectators had so much affected one of the crowd "
572 "that he did not await the arrival of the vessel in harbor, but"
573 " jumping into a small skiff, desired to be pulled alongside "
574 "the Pharaon, which he reached as she rounded into La Reserve "
575 "basin. When the young man on board saw this person approach, "
576 "he left his station by the pilot, and, hat in hand, leaned "
577 "over the ship's bulwarks. He was a fine, tall, slim young "
578 "fellow of eighteen or twenty, with black eyes, and hair as "
579 "dark as a raven's wing; and his whole appearance bespoke that "
580 "calmness and resolution peculiar to men accustomed from their "
581 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
582 "cried the man in the skiff. \"What's the matter? and why have "
583 "you such an air of sadness aboard?\" \"A great misfortune, M. "
584 "Morrel,\" replied the young man,--\"a great misfortune, for me"
585 " especially! Off Civita Vecchia we lost our brave Captain "
586 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
587 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
588 " that head. But poor Captain Leclere--\" \"What happened to "
589 "him?\" asked the owner, with an air of considerable "
590 "resignation. \"What happened to the worthy captain?\" \"He "
591 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
592 "brain-fever in dreadful agony.\" Then turning to the crew, "
593 "he said, \"Bear a hand there, to take in sail!\" All hands "
594 "obeyed, and at once the eight or ten seamen who composed the "
595 "crew, sprang to their respective stations at the spanker "
596 "brails and outhaul, topsail sheets and halyards, the jib "
597 "downhaul, and the topsail clewlines and buntlines. The young "
598 "sailor gave a look to see that his orders were promptly and "
599 "accurately obeyed, and then turned again to the owner. \"And "
600 "how did this misfortune occur?\" inquired the latter, resuming"
601 " the interrupted conversation. \"Alas, sir, in the most "
602 "unexpected manner. After a long talk with the harbor-master, "
603 "Captain Leclere left Naples greatly disturbed in mind. In "
604 "twenty-four hours he was attacked by a fever, and died three "
605 "days afterwards. We performed the usual burial service, and he"
606 " is at his rest, sewn up in his hammock with a thirty-six "
607 "pound shot at his head and his heels, off El Giglio island. "
608 "We bring to his widow his sword and cross of honor. It was "
609 "worth while, truly,\" added the young man with a melancholy "
610 "smile, \"to make war against the English for ten years, and "
611 "to die in his bed at last, like everybody else.";
613 #define QUOTE_LEN_64B (64)
614 #define QUOTE_LEN_128B (128)
615 #define QUOTE_LEN_256B (256)
616 #define QUOTE_LEN_512B (512)
617 #define QUOTE_LEN_768B (768)
618 #define QUOTE_LEN_1024B (1024)
619 #define QUOTE_LEN_1280B (1280)
620 #define QUOTE_LEN_1536B (1536)
621 #define QUOTE_LEN_1792B (1792)
622 #define QUOTE_LEN_2048B (2048)
625 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
627 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
629 #define CIPHER_KEY_LENGTH_AES_CBC (16)
630 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
632 static uint8_t aes_cbc_128_key[] = {
633 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
634 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
636 static uint8_t aes_cbc_128_iv[] = {
637 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
638 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
640 static uint8_t hmac_sha256_key[] = {
641 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
642 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
643 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
644 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
647 /* Cipher text output */
649 static const uint8_t AES_CBC_ciphertext_64B[] = {
650 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
651 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
652 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
653 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
654 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
655 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
656 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
657 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
660 static const uint8_t AES_CBC_ciphertext_128B[] = {
661 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
662 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
663 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
664 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
665 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
666 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
667 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
668 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
669 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
670 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
671 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
672 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
673 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
674 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
675 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
676 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
679 static const uint8_t AES_CBC_ciphertext_256B[] = {
680 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
681 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
682 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
683 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
684 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
685 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
686 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
687 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
688 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
689 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
690 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
691 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
692 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
693 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
694 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
695 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
696 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
697 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
698 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
699 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
700 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
701 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
702 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
703 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
704 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
705 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
706 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
707 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
708 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
709 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
710 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
711 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
714 static const uint8_t AES_CBC_ciphertext_512B[] = {
715 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
716 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
717 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
718 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
719 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
720 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
721 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
722 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
723 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
724 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
725 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
726 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
727 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
728 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
729 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
730 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
731 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
732 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
733 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
734 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
735 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
736 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
737 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
738 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
739 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
740 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
741 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
742 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
743 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
744 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
745 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
746 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
747 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
748 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
749 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
750 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
751 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
752 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
753 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
754 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
755 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
756 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
757 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
758 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
759 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
760 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
761 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
762 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
763 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
764 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
765 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
766 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
767 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
768 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
769 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
770 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
771 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
772 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
773 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
774 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
775 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
776 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
777 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
778 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
781 static const uint8_t AES_CBC_ciphertext_768B[] = {
782 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
783 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
784 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
785 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
786 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
787 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
788 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
789 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
790 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
791 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
792 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
793 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
794 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
795 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
796 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
797 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
798 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
799 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
800 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
801 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
802 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
803 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
804 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
805 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
806 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
807 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
808 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
809 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
810 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
811 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
812 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
813 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
814 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
815 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
816 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
817 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
818 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
819 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
820 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
821 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
822 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
823 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
824 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
825 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
826 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
827 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
828 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
829 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
830 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
831 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
832 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
833 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
834 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
835 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
836 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
837 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
838 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
839 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
840 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
841 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
842 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
843 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
844 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
845 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
846 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
847 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
848 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
849 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
850 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
851 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
852 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
853 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
854 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
855 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
856 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
857 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
858 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
859 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
860 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
861 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
862 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
863 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
864 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
865 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
866 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
867 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
868 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
869 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
870 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
871 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
872 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
873 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
874 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
875 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
876 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
877 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
880 static const uint8_t AES_CBC_ciphertext_1024B[] = {
881 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
882 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
883 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
884 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
885 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
886 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
887 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
888 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
889 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
890 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
891 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
892 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
893 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
894 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
895 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
896 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
897 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
898 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
899 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
900 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
901 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
902 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
903 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
904 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
905 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
906 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
907 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
908 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
909 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
910 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
911 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
912 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
913 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
914 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
915 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
916 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
917 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
918 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
919 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
920 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
921 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
922 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
923 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
924 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
925 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
926 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
927 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
928 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
929 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
930 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
931 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
932 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
933 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
934 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
935 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
936 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
937 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
938 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
939 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
940 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
941 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
942 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
943 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
944 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
945 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
946 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
947 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
948 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
949 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
950 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
951 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
952 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
953 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
954 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
955 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
956 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
957 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
958 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
959 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
960 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
961 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
962 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
963 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
964 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
965 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
966 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
967 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
968 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
969 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
970 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
971 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
972 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
973 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
974 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
975 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
976 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
977 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
978 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
979 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
980 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
981 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
982 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
983 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
984 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
985 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
986 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
987 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
988 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
989 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
990 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
991 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
992 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
993 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
994 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
995 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
996 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
997 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
998 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
999 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
1000 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
1001 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
1002 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
1003 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
1004 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
1005 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
1006 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
1007 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
1008 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
1011 static const uint8_t AES_CBC_ciphertext_1280B[] = {
1012 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
1013 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
1014 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
1015 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
1016 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
1017 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
1018 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
1019 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
1020 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
1021 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
1022 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
1023 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
1024 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
1025 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
1026 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
1027 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
1028 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
1029 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
1030 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
1031 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
1032 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
1033 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
1034 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
1035 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
1036 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
1037 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
1038 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
1039 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
1040 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
1041 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
1042 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
1043 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
1044 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
1045 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
1046 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
1047 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
1048 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
1049 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1050 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1051 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1052 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1053 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1054 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1055 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1056 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1057 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1058 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1059 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1060 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1061 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1062 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1063 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1064 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1065 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1066 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1067 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1068 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1069 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1070 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1071 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1072 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1073 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1074 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1075 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1076 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1077 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1078 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1079 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1080 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1081 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1082 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1083 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1084 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1085 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1086 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1087 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1088 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1089 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1090 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1091 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1092 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1093 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1094 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1095 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1096 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1097 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1098 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1099 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1100 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1101 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1102 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1103 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1104 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1105 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1106 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1107 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1108 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1109 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1110 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1111 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1112 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1113 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1114 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1115 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1116 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1117 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1118 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1119 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1120 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1121 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1122 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1123 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1124 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1125 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1126 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1127 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1128 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1129 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1130 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1131 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1132 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1133 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1134 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1135 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1136 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1137 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1138 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1139 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1140 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1141 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1142 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1143 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1144 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1145 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1146 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1147 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1148 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1149 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1150 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1151 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1152 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1153 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1154 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1155 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1156 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1157 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1158 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1159 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1160 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1161 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1162 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1163 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1164 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1165 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1166 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1167 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1168 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1169 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1170 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1171 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1174 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1175 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1176 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1177 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1178 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1179 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1180 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1181 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1182 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1183 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1184 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1185 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1186 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1187 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1188 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1189 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1190 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1191 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1192 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1193 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1194 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1195 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1196 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1197 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1198 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1199 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1200 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1201 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1202 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1203 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1204 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1205 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1206 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1207 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1208 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1209 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1210 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1211 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1212 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1213 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1214 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1215 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1216 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1217 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1218 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1219 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1220 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1221 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1222 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1223 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1224 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1225 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1226 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1227 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1228 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1229 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1230 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1231 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1232 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1233 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1234 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1235 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1236 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1237 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1238 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1239 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1240 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1241 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1242 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1243 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1244 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1245 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1246 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1247 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1248 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1249 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1250 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1251 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1252 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1253 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1254 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1255 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1256 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1257 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1258 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1259 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1260 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1261 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1262 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1263 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1264 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1265 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1266 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1267 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1268 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1269 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1270 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1271 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1272 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1273 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1274 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1275 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1276 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1277 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1278 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1279 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1280 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1281 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1282 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1283 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1284 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1285 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1286 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1287 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1288 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1289 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1290 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1291 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1292 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1293 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1294 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1295 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1296 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1297 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1298 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1299 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1300 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1301 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1302 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1303 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1304 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1305 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1306 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1307 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1308 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1309 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1310 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1311 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1312 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1313 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1314 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1315 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1316 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1317 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1318 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1319 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1320 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1321 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1322 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1323 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1324 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1325 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1326 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1327 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1328 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1329 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1330 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1331 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1332 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1333 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1334 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1335 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1336 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1337 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1338 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1339 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1340 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1341 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1342 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1343 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1344 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1345 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1346 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1347 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1348 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1349 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1350 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1351 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1352 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1353 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1354 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1355 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1356 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1357 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1358 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1359 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1360 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1361 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1362 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1363 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1364 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1365 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1366 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1369 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1370 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1371 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1372 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1373 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1374 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1375 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1376 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1377 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1378 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1379 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1380 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1381 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1382 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1383 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1384 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1385 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1386 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1387 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1388 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1389 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1390 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1391 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1392 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1393 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1394 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1395 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1396 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1397 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1398 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1399 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1400 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1401 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1402 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1403 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1404 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1405 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1406 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1407 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1408 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1409 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1410 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1411 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1412 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1413 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1414 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1415 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1416 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1417 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1418 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1419 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1420 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1421 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1422 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1423 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1424 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1425 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1426 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1427 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1428 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1429 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1430 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1431 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1432 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1433 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1434 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1435 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1436 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1437 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1438 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1439 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1440 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1441 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1442 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1443 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1444 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1445 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1446 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1447 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1448 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1449 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1450 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1451 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1452 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1453 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1454 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1455 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1456 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1457 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1458 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1459 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1460 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1461 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1462 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1463 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1464 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1465 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1466 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1467 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1468 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1469 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1470 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1471 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1472 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1473 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1474 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1475 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1476 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1477 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1478 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1479 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1480 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1481 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1482 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1483 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1484 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1485 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1486 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1487 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1488 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1489 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1490 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1491 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1492 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1493 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1494 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1495 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1496 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1497 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1498 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1499 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1500 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1501 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1502 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1503 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1504 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1505 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1506 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1507 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1508 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1509 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1510 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1511 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1512 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1513 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1514 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1515 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1516 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1517 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1518 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1519 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1520 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1521 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1522 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1523 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1524 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1525 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1526 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1527 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1528 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1529 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1530 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1531 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1532 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1533 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1534 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1535 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1536 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1537 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1538 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1539 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1540 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1541 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1542 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1543 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1544 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1545 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1546 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1547 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1548 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1549 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1550 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1551 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1552 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1553 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1554 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1555 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1556 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1557 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1558 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1559 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1560 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1561 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1562 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1563 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1564 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1565 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1566 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1567 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1568 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1569 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1570 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1571 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1572 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1573 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1574 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1575 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1576 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1577 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1578 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1579 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1580 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1581 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1582 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1583 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1584 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1585 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1586 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1587 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1588 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1589 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1590 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1591 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1592 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1593 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1596 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1597 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1598 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1599 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1600 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1601 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1602 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1603 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1604 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1605 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1606 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1607 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1608 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1609 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1610 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1611 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1612 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1613 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1614 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1615 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1616 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1617 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1618 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1619 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1620 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1621 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1622 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1623 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1624 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1625 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1626 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1627 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1628 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1629 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1630 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1631 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1632 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1633 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1634 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1635 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1636 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1637 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1638 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1639 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1640 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1641 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1642 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1643 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1644 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1645 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1646 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1647 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1648 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1649 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1650 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1651 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1652 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1653 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1654 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1655 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1656 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1657 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1658 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1659 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1660 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1661 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1662 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1663 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1664 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1665 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1666 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1667 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1668 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1669 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1670 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1671 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1672 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1673 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1674 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1675 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1676 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1677 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1678 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1679 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1680 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1681 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1682 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1683 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1684 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1685 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1686 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1687 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1688 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1689 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1690 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1691 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1692 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1693 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1694 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1695 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1696 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1697 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1698 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1699 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1700 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1701 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1702 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1703 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1704 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1705 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1706 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1707 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1708 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1709 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1710 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1711 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1712 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1713 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1714 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1715 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1716 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1717 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1718 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1719 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1720 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1721 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1722 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1723 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1724 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1725 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1726 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1727 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1728 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1729 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1730 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1731 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1732 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1733 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1734 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1735 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1736 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1737 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1738 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1739 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1740 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1741 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1742 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1743 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1744 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1745 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1746 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1747 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1748 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1749 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1750 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1751 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1752 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1753 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1754 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1755 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1756 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1757 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1758 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1759 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1760 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1761 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1762 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1763 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1764 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1765 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1766 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1767 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1768 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1769 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1770 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1771 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1772 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1773 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1774 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1775 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1776 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1777 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1778 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1779 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1780 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1781 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1782 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1783 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1784 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1785 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1786 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1787 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1788 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1789 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1790 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1791 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1792 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1793 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1794 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1795 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1796 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1797 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1798 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1799 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1800 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1801 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1802 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1803 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1804 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1805 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1806 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1807 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1808 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1809 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1810 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1811 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1812 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1813 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1814 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1815 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1816 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1817 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1818 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1819 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1820 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1821 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1822 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1823 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1824 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1825 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1826 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1827 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1828 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1829 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1830 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1831 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1832 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1833 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1834 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1835 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1836 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1837 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1838 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1839 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1840 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1841 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1842 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1843 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1844 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1845 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1846 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1847 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1848 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1849 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1850 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1851 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1852 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1856 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1857 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1858 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1859 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1860 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1863 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1864 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1865 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1866 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1867 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1870 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1871 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1872 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1873 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1874 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1877 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1878 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1879 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1880 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1881 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1884 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1885 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1886 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1887 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1888 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1891 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1892 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1893 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1894 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1895 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1898 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1899 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1900 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1901 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1902 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1905 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1906 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1907 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1908 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1909 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1912 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1913 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1914 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1915 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1916 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1919 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1920 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1921 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1922 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1923 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1926 struct crypto_data_params {
1929 const char *plaintext;
1930 struct crypto_expected_output {
1931 const uint8_t *ciphertext;
1932 const uint8_t *digest;
1936 #define MAX_PACKET_SIZE_INDEX 10
1938 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1939 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1940 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1941 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1942 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1943 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1944 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1945 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1946 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1947 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1948 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1949 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1950 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1951 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1952 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1953 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1954 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1955 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1956 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1957 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1958 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1962 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1964 uint32_t num_to_submit = 4096;
1965 struct rte_crypto_op *c_ops[num_to_submit];
1966 struct rte_crypto_op *proc_ops[num_to_submit];
1967 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1968 uint32_t burst_sent, burst_received;
1969 uint32_t i, burst_size, num_sent, num_received;
1970 struct crypto_testsuite_params *ts_params = &testsuite_params;
1971 struct crypto_unittest_params *ut_params = &unittest_params;
1972 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1974 if (rte_cryptodev_count() == 0) {
1975 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1979 /* Setup Cipher Parameters */
1980 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1981 ut_params->cipher_xform.next = &ut_params->auth_xform;
1983 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1984 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1985 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1986 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1989 /* Setup HMAC Parameters */
1990 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1991 ut_params->auth_xform.next = NULL;
1993 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1994 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1995 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1996 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1997 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1999 /* Create Crypto session*/
2000 ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
2001 &ut_params->cipher_xform);
2003 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
2005 /* Generate Crypto op data structure(s) */
2006 for (i = 0; i < num_to_submit ; i++) {
2007 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
2008 data_params[0].expected.ciphertext,
2009 data_params[0].length, 0);
2010 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2012 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
2013 DIGEST_BYTE_LENGTH_SHA256);
2014 TEST_ASSERT_NOT_NULL(ut_params->digest,
2015 "no room to append digest");
2017 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
2018 DIGEST_BYTE_LENGTH_SHA256);
2021 struct rte_crypto_op *op =
2022 rte_crypto_op_alloc(ts_params->op_mpool,
2023 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2025 rte_crypto_op_attach_sym_session(op, ut_params->sess);
2027 op->sym->auth.digest.data = ut_params->digest;
2028 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2029 data_params[0].length);
2030 op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
2032 op->sym->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2033 op->sym->auth.data.length = data_params[0].length;
2036 op->sym->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(m,
2037 CIPHER_IV_LENGTH_AES_CBC);
2038 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2039 op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2041 rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv,
2042 CIPHER_IV_LENGTH_AES_CBC);
2044 op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2045 op->sym->cipher.data.length = data_params[0].length;
2052 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
2053 "algorithm with a constant request size of %u.",
2054 data_params[0].length);
2055 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2056 "cost for each request.");
2057 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2058 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2059 "(assuming 0 retries)");
2060 for (i = 2; i <= 128 ; i *= 2) {
2067 while (num_sent < num_to_submit) {
2068 start_cycles = rte_rdtsc_precise();
2069 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2070 0, &c_ops[num_sent],
2071 ((num_to_submit-num_sent) < burst_size) ?
2072 num_to_submit-num_sent : burst_size);
2073 if (burst_sent == 0)
2076 num_sent += burst_sent;
2077 end_cycles = rte_rdtsc_precise();
2078 total_cycles += (end_cycles - start_cycles);
2080 * Wait until requests have been sent.
2084 start_cycles = rte_rdtsc_precise();
2085 burst_received = rte_cryptodev_dequeue_burst(
2086 dev_num, 0, proc_ops, burst_size);
2087 if (burst_received == 0)
2090 num_received += burst_received;
2091 end_cycles = rte_rdtsc_precise();
2092 total_cycles += end_cycles - start_cycles;
2095 while (num_received != num_to_submit) {
2096 if (gbl_cryptodev_perftest_devtype ==
2097 RTE_CRYPTODEV_AESNI_MB_PMD)
2098 rte_cryptodev_enqueue_burst(dev_num, 0,
2101 burst_received = rte_cryptodev_dequeue_burst(
2102 dev_num, 0, proc_ops, burst_size);
2103 if (burst_received == 0)
2106 num_received += burst_received;
2109 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2110 num_sent, num_received, burst_size);
2111 printf("\t\t%"PRIu64, retries);
2112 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2116 for (i = 0; i < num_to_submit ; i++) {
2117 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2118 rte_crypto_op_free(c_ops[i]);
2120 return TEST_SUCCESS;
2124 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2126 uint32_t num_to_submit = pparams->total_operations;
2127 struct rte_crypto_op *c_ops[num_to_submit];
2128 struct rte_crypto_op *proc_ops[num_to_submit];
2129 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2130 uint32_t burst_sent = 0, burst_received = 0;
2131 uint32_t i, burst_size, num_sent, num_ops_received;
2132 struct crypto_testsuite_params *ts_params = &testsuite_params;
2133 static struct rte_cryptodev_sym_session *sess;
2135 if (rte_cryptodev_count() == 0) {
2136 printf("\nNo crypto devices found. Is PMD build configured?\n");
2137 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2141 /* Create Crypto session*/
2142 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2143 pparams->chain, pparams->cipher_algo,
2144 pparams->cipher_key_length, pparams->auth_algo);
2145 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2147 /* Generate Crypto op data structure(s)*/
2148 for (i = 0; i < num_to_submit ; i++) {
2149 struct rte_mbuf *m = test_perf_create_pktmbuf(
2152 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2154 struct rte_crypto_op *op =
2155 rte_crypto_op_alloc(ts_params->op_mpool,
2156 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2157 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2159 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size,
2160 get_auth_digest_length(pparams->auth_algo));
2161 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2166 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2167 "Packet Size %u bytes",
2168 pmd_name(gbl_cryptodev_perftest_devtype),
2169 ts_params->dev_id, 0,
2170 chain_mode_name(pparams->chain),
2171 cipher_algo_name(pparams->cipher_algo),
2172 auth_algo_name(pparams->auth_algo),
2174 printf("\nOps Tx\tOps Rx\tOps/burst ");
2175 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2177 for (i = 2; i <= 128 ; i *= 2) {
2179 num_ops_received = 0;
2184 while (num_sent < num_to_submit) {
2185 start_cycles = rte_rdtsc_precise();
2186 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2187 0, &c_ops[num_sent],
2188 ((num_to_submit-num_sent) < burst_size) ?
2189 num_to_submit-num_sent : burst_size);
2190 end_cycles = rte_rdtsc_precise();
2191 if (burst_sent == 0)
2193 num_sent += burst_sent;
2194 total_cycles += (end_cycles - start_cycles);
2196 /* Wait until requests have been sent. */
2200 start_cycles = rte_rdtsc_precise();
2201 burst_received = rte_cryptodev_dequeue_burst(
2202 ts_params->dev_id, 0, proc_ops, burst_size);
2203 end_cycles = rte_rdtsc_precise();
2204 if (burst_received < burst_sent)
2206 num_ops_received += burst_received;
2208 total_cycles += end_cycles - start_cycles;
2211 while (num_ops_received != num_to_submit) {
2212 if (gbl_cryptodev_perftest_devtype ==
2213 RTE_CRYPTODEV_AESNI_MB_PMD)
2214 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2216 start_cycles = rte_rdtsc_precise();
2217 burst_received = rte_cryptodev_dequeue_burst(
2218 ts_params->dev_id, 0, proc_ops, burst_size);
2219 end_cycles = rte_rdtsc_precise();
2220 total_cycles += end_cycles - start_cycles;
2221 if (burst_received == 0)
2223 num_ops_received += burst_received;
2226 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2227 printf("\t\t%"PRIu64, retries);
2228 printf("\t%"PRIu64, failed_polls);
2229 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2230 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2231 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2235 for (i = 0; i < num_to_submit ; i++) {
2236 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2237 rte_crypto_op_free(c_ops[i]);
2239 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2241 return TEST_SUCCESS;
2245 test_perf_snow3G_vary_burst_size(void)
2247 unsigned total_operations = 4096;
2248 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2249 uint16_t buf_lengths[] = {40};
2252 struct perf_test_params params_set[] = {
2254 .chain = CIPHER_ONLY,
2255 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2256 .cipher_key_length = 16,
2257 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2261 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2262 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2263 .cipher_key_length = 16
2267 printf("\n\nStart %s.", __func__);
2268 printf("\nThis Test measures the average IA cycle cost using a "
2269 "constant request(packet) size. ");
2270 printf("Cycle cost is only valid when indicators show device is not busy,"
2271 " i.e. Retries and EmptyPolls = 0");
2273 for (i = 0; i < RTE_DIM(params_set); i++) {
2275 params_set[i].total_operations = total_operations;
2278 j < RTE_DIM(buf_lengths);
2281 params_set[i].buf_size = buf_lengths[j];
2283 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2292 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2294 uint32_t num_to_submit = pparams->total_operations;
2295 struct rte_crypto_op *c_ops[num_to_submit];
2296 struct rte_crypto_op *proc_ops[num_to_submit];
2297 uint64_t failed_polls, retries, start_cycles,
2298 end_cycles, total_cycles = 0;
2299 uint32_t burst_sent = 0, burst_received = 0;
2300 uint32_t i, burst_size, num_sent, num_ops_received;
2302 struct crypto_testsuite_params *ts_params = &testsuite_params;
2304 static struct rte_cryptodev_sym_session *sess;
2306 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2307 (struct rte_crypto_op *, struct rte_mbuf *,
2308 struct rte_cryptodev_sym_session *,
2309 unsigned int, unsigned int,
2312 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2314 if (rte_cryptodev_count() == 0) {
2315 printf("\nNo crypto devices found. Is PMD build configured?\n");
2319 /* Create Crypto session*/
2320 sess = test_perf_create_openssl_session(ts_params->dev_id,
2321 pparams->chain, pparams->cipher_algo,
2322 pparams->cipher_key_length, pparams->auth_algo);
2323 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2325 /* Generate Crypto op data structure(s)*/
2326 for (i = 0; i < num_to_submit ; i++) {
2327 struct rte_mbuf *m = test_perf_create_pktmbuf(
2330 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2332 struct rte_crypto_op *op =
2333 rte_crypto_op_alloc(ts_params->op_mpool,
2334 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2335 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2337 switch (pparams->cipher_algo) {
2338 case RTE_CRYPTO_CIPHER_3DES_CBC:
2339 case RTE_CRYPTO_CIPHER_3DES_CTR:
2340 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2342 case RTE_CRYPTO_CIPHER_AES_CBC:
2343 case RTE_CRYPTO_CIPHER_AES_CTR:
2344 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2346 case RTE_CRYPTO_CIPHER_AES_GCM:
2347 test_perf_set_crypto_op =
2348 test_perf_set_crypto_op_aes_gcm;
2354 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2355 digest_length, pparams->chain);
2356 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2361 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2362 "auth_algo:%s, Packet Size %u bytes",
2363 pmd_name(gbl_cryptodev_perftest_devtype),
2364 ts_params->dev_id, 0,
2365 chain_mode_name(pparams->chain),
2366 cipher_algo_name(pparams->cipher_algo),
2367 pparams->cipher_key_length,
2368 auth_algo_name(pparams->auth_algo),
2370 printf("\nOps Tx\tOps Rx\tOps/burst ");
2371 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2374 for (i = 2; i <= 128 ; i *= 2) {
2376 num_ops_received = 0;
2381 while (num_sent < num_to_submit) {
2382 start_cycles = rte_rdtsc_precise();
2383 burst_sent = rte_cryptodev_enqueue_burst(
2385 0, &c_ops[num_sent],
2386 ((num_to_submit - num_sent) <
2388 num_to_submit - num_sent : burst_size);
2389 end_cycles = rte_rdtsc_precise();
2390 if (burst_sent == 0)
2392 num_sent += burst_sent;
2393 total_cycles += (end_cycles - start_cycles);
2395 /* Wait until requests have been sent. */
2398 start_cycles = rte_rdtsc_precise();
2399 burst_received = rte_cryptodev_dequeue_burst(
2400 ts_params->dev_id, 0, proc_ops,
2402 end_cycles = rte_rdtsc_precise();
2403 if (burst_received < burst_sent)
2405 num_ops_received += burst_received;
2407 total_cycles += end_cycles - start_cycles;
2410 while (num_ops_received != num_to_submit) {
2411 /* Sending 0 length burst to flush sw crypto device */
2412 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2415 start_cycles = rte_rdtsc_precise();
2416 burst_received = rte_cryptodev_dequeue_burst(
2417 ts_params->dev_id, 0, proc_ops,
2419 end_cycles = rte_rdtsc_precise();
2421 total_cycles += end_cycles - start_cycles;
2422 if (burst_received == 0)
2424 num_ops_received += burst_received;
2427 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2428 printf("\t\t%"PRIu64, retries);
2429 printf("\t%"PRIu64, failed_polls);
2430 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2431 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2433 printf("\t\t%"PRIu64,
2435 (num_ops_received * pparams->buf_size));
2439 for (i = 0; i < num_to_submit ; i++) {
2440 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2441 rte_crypto_op_free(c_ops[i]);
2443 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2445 return TEST_SUCCESS;
2449 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2451 uint32_t num_to_submit = pparams->total_operations;
2452 struct rte_crypto_op *c_ops[num_to_submit];
2453 struct rte_crypto_op *proc_ops[num_to_submit];
2454 uint64_t failed_polls, retries, start_cycles, end_cycles,
2456 uint32_t burst_sent = 0, burst_received = 0;
2457 uint32_t i, burst_size, num_sent, num_ops_received;
2460 struct crypto_testsuite_params *ts_params = &testsuite_params;
2462 static struct rte_cryptodev_sym_session *sess;
2464 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2466 if (rte_cryptodev_count() == 0) {
2467 printf("\nNo crypto devices found. Is PMD build configured?\n");
2471 /* Create Crypto session*/
2472 sess = test_perf_create_armv8_session(ts_params->dev_id,
2473 pparams->chain, pparams->cipher_algo,
2474 pparams->cipher_key_length, pparams->auth_algo);
2475 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2477 /* Generate Crypto op data structure(s)*/
2478 for (i = 0; i < num_to_submit ; i++) {
2479 struct rte_mbuf *m = test_perf_create_pktmbuf(
2482 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2484 struct rte_crypto_op *op =
2485 rte_crypto_op_alloc(ts_params->op_mpool,
2486 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2487 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2489 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2490 digest_length, pparams->chain);
2491 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2496 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2497 "auth_algo:%s, Packet Size %u bytes",
2498 pmd_name(gbl_cryptodev_perftest_devtype),
2499 ts_params->dev_id, 0,
2500 chain_mode_name(pparams->chain),
2501 cipher_algo_name(pparams->cipher_algo),
2502 pparams->cipher_key_length,
2503 auth_algo_name(pparams->auth_algo),
2505 printf("\nOps Tx\tOps Rx\tOps/burst ");
2507 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2509 for (i = 2; i <= 128 ; i *= 2) {
2511 num_ops_received = 0;
2516 while (num_sent < num_to_submit) {
2517 if ((num_to_submit - num_sent) < burst_size)
2518 nb_ops = num_to_submit - num_sent;
2520 nb_ops = burst_size;
2522 start_cycles = rte_rdtsc();
2523 burst_sent = rte_cryptodev_enqueue_burst(
2525 0, &c_ops[num_sent],
2527 end_cycles = rte_rdtsc();
2529 if (burst_sent == 0)
2531 num_sent += burst_sent;
2532 total_cycles += (end_cycles - start_cycles);
2534 start_cycles = rte_rdtsc();
2535 burst_received = rte_cryptodev_dequeue_burst(
2536 ts_params->dev_id, 0, proc_ops,
2538 end_cycles = rte_rdtsc();
2539 if (burst_received < burst_sent)
2541 num_ops_received += burst_received;
2543 total_cycles += end_cycles - start_cycles;
2546 while (num_ops_received != num_to_submit) {
2547 /* Sending 0 length burst to flush sw crypto device */
2548 rte_cryptodev_enqueue_burst(
2549 ts_params->dev_id, 0, NULL, 0);
2551 start_cycles = rte_rdtsc();
2552 burst_received = rte_cryptodev_dequeue_burst(
2553 ts_params->dev_id, 0, proc_ops, burst_size);
2554 end_cycles = rte_rdtsc();
2556 total_cycles += end_cycles - start_cycles;
2557 if (burst_received == 0)
2559 num_ops_received += burst_received;
2562 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2563 printf("\t\t%"PRIu64, retries);
2564 printf("\t%"PRIu64, failed_polls);
2565 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2566 printf("\t\t%"PRIu64,
2567 (total_cycles/num_ops_received)*burst_size);
2568 printf("\t\t%"PRIu64,
2569 total_cycles/(num_ops_received*pparams->buf_size));
2573 for (i = 0; i < num_to_submit ; i++) {
2574 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2575 rte_crypto_op_free(c_ops[i]);
2578 return TEST_SUCCESS;
2581 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2584 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2586 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2588 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2590 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2592 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2594 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2596 case RTE_CRYPTO_AUTH_AES_GCM:
2603 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2606 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2608 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2609 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2610 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2611 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2612 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2613 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2614 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2615 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2616 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2617 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2618 case RTE_CRYPTO_AUTH_AES_GCM:
2619 return DIGEST_BYTE_LENGTH_AES_GCM;
2625 static uint8_t aes_key[] = {
2626 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2627 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2628 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2629 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2632 static uint8_t aes_iv[] = {
2633 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2634 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2637 static uint8_t aes_gcm_aad[] = {
2638 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2639 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2642 static uint8_t triple_des_key[] = {
2643 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2644 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2645 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2648 static uint8_t triple_des_iv[] = {
2649 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2652 static uint8_t hmac_sha_key[] = {
2653 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2654 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2655 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2656 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2657 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2658 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2659 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2660 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2661 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2662 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2663 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2664 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2665 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2666 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2667 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2668 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2671 static uint8_t snow3g_cipher_key[] = {
2672 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2673 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2676 static uint8_t snow3g_iv[] = {
2677 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2678 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2681 static uint8_t snow3g_hash_key[] = {
2682 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2683 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2686 static struct rte_cryptodev_sym_session *
2687 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2688 enum rte_crypto_cipher_algorithm cipher_algo,
2689 unsigned cipher_key_len,
2690 enum rte_crypto_auth_algorithm auth_algo)
2692 struct rte_crypto_sym_xform cipher_xform = { 0 };
2693 struct rte_crypto_sym_xform auth_xform = { 0 };
2696 /* Setup Cipher Parameters */
2697 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2698 cipher_xform.cipher.algo = cipher_algo;
2699 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2701 cipher_xform.cipher.key.data = aes_key;
2702 cipher_xform.cipher.key.length = cipher_key_len;
2703 if (chain != CIPHER_ONLY) {
2704 /* Setup HMAC Parameters */
2705 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2706 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2707 auth_xform.auth.algo = auth_algo;
2708 auth_xform.auth.key.data = hmac_sha_key;
2709 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2710 auth_xform.auth.digest_length =
2711 get_auth_digest_length(auth_algo);
2715 cipher_xform.next = &auth_xform;
2716 auth_xform.next = NULL;
2717 /* Create Crypto session*/
2718 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2720 auth_xform.next = &cipher_xform;
2721 cipher_xform.next = NULL;
2722 /* Create Crypto session*/
2723 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2725 cipher_xform.next = NULL;
2726 /* Create Crypto session*/
2727 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2733 #define SNOW3G_CIPHER_IV_LENGTH 16
2735 static struct rte_cryptodev_sym_session *
2736 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2737 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2738 enum rte_crypto_auth_algorithm auth_algo)
2740 struct rte_crypto_sym_xform cipher_xform = {0};
2741 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 cipher_xform.cipher.key.data = snow3g_cipher_key;
2750 cipher_xform.cipher.key.length = cipher_key_len;
2752 /* Setup HMAC Parameters */
2753 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2754 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2755 auth_xform.auth.algo = auth_algo;
2757 auth_xform.auth.add_auth_data_length = SNOW3G_CIPHER_IV_LENGTH;
2758 auth_xform.auth.key.data = snow3g_hash_key;
2759 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2760 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2764 cipher_xform.next = &auth_xform;
2765 auth_xform.next = NULL;
2766 /* Create Crypto session*/
2767 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2769 auth_xform.next = &cipher_xform;
2770 cipher_xform.next = NULL;
2771 /* Create Crypto session*/
2772 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2774 cipher_xform.next = NULL;
2775 /* Create Crypto session*/
2776 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2778 auth_xform.next = NULL;
2779 /* Create Crypto session */
2780 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2786 static struct rte_cryptodev_sym_session *
2787 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2788 enum rte_crypto_cipher_algorithm cipher_algo,
2789 unsigned int cipher_key_len,
2790 enum rte_crypto_auth_algorithm auth_algo)
2792 struct rte_crypto_sym_xform cipher_xform = { 0 };
2793 struct rte_crypto_sym_xform auth_xform = { 0 };
2795 /* Setup Cipher Parameters */
2796 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2797 cipher_xform.cipher.algo = cipher_algo;
2798 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2800 switch (cipher_algo) {
2801 case RTE_CRYPTO_CIPHER_3DES_CBC:
2802 case RTE_CRYPTO_CIPHER_3DES_CTR:
2803 cipher_xform.cipher.key.data = triple_des_key;
2805 case RTE_CRYPTO_CIPHER_AES_CBC:
2806 case RTE_CRYPTO_CIPHER_AES_CTR:
2807 case RTE_CRYPTO_CIPHER_AES_GCM:
2808 cipher_xform.cipher.key.data = aes_key;
2814 cipher_xform.cipher.key.length = cipher_key_len;
2816 /* Setup Auth Parameters */
2817 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2818 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2819 auth_xform.auth.algo = auth_algo;
2821 switch (auth_algo) {
2822 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2823 auth_xform.auth.key.data = hmac_sha_key;
2825 case RTE_CRYPTO_AUTH_AES_GCM:
2826 auth_xform.auth.key.data = NULL;
2832 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2833 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2837 cipher_xform.next = &auth_xform;
2838 auth_xform.next = NULL;
2839 /* Create Crypto session*/
2840 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2842 auth_xform.next = &cipher_xform;
2843 cipher_xform.next = NULL;
2844 /* Create Crypto session*/
2845 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2851 static struct rte_cryptodev_sym_session *
2852 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2853 enum rte_crypto_cipher_algorithm cipher_algo,
2854 unsigned int cipher_key_len,
2855 enum rte_crypto_auth_algorithm auth_algo)
2857 struct rte_crypto_sym_xform cipher_xform = { 0 };
2858 struct rte_crypto_sym_xform auth_xform = { 0 };
2860 /* Setup Cipher Parameters */
2861 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2862 cipher_xform.cipher.algo = cipher_algo;
2864 switch (cipher_algo) {
2865 case RTE_CRYPTO_CIPHER_AES_CBC:
2866 cipher_xform.cipher.key.data = aes_cbc_128_key;
2872 cipher_xform.cipher.key.length = cipher_key_len;
2874 /* Setup Auth Parameters */
2875 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2876 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2877 auth_xform.auth.algo = auth_algo;
2879 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2883 cipher_xform.next = &auth_xform;
2884 auth_xform.next = NULL;
2885 /* Encrypt and hash the result */
2886 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2887 /* Create Crypto session*/
2888 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2890 auth_xform.next = &cipher_xform;
2891 cipher_xform.next = NULL;
2892 /* Hash encrypted message and decrypt */
2893 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2894 /* Create Crypto session*/
2895 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2901 #define AES_CIPHER_IV_LENGTH 16
2902 #define AES_GCM_AAD_LENGTH 16
2903 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
2905 static struct rte_mbuf *
2906 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2908 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2910 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2911 rte_pktmbuf_free(m);
2915 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2920 static inline struct rte_crypto_op *
2921 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2922 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2923 unsigned int digest_len, enum chain_mode chain)
2925 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2926 rte_crypto_op_free(op);
2930 /* Authentication Parameters */
2931 if (chain == CIPHER_ONLY) {
2932 op->sym->auth.digest.data = NULL;
2933 op->sym->auth.digest.phys_addr = 0;
2934 op->sym->auth.digest.length = 0;
2935 op->sym->auth.aad.data = NULL;
2936 op->sym->auth.aad.length = 0;
2937 op->sym->auth.data.offset = 0;
2938 op->sym->auth.data.length = 0;
2940 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
2941 uint8_t *, AES_CIPHER_IV_LENGTH + data_len);
2942 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2943 AES_CIPHER_IV_LENGTH + data_len);
2944 op->sym->auth.digest.length = digest_len;
2945 op->sym->auth.data.offset = AES_CIPHER_IV_LENGTH;
2946 op->sym->auth.data.length = data_len;
2950 /* Cipher Parameters */
2951 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
2952 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2953 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2955 rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH);
2957 op->sym->cipher.data.offset = AES_CIPHER_IV_LENGTH;
2958 op->sym->cipher.data.length = data_len;
2965 static inline struct rte_crypto_op *
2966 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2967 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2968 unsigned int digest_len, enum chain_mode chain __rte_unused)
2970 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2971 rte_crypto_op_free(op);
2975 /* Authentication Parameters */
2976 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2977 (m->data_off + data_len);
2978 op->sym->auth.digest.phys_addr =
2979 rte_pktmbuf_mtophys_offset(m, data_len);
2980 op->sym->auth.digest.length = digest_len;
2981 op->sym->auth.aad.data = aes_gcm_aad;
2982 op->sym->auth.aad.length = AES_GCM_AAD_LENGTH;
2984 /* Cipher Parameters */
2985 op->sym->cipher.iv.data = aes_iv;
2986 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2988 /* Data lengths/offsets Parameters */
2989 op->sym->auth.data.offset = 0;
2990 op->sym->auth.data.length = data_len;
2992 op->sym->cipher.data.offset = 0;
2993 op->sym->cipher.data.length = data_len;
3000 static inline struct rte_crypto_op *
3001 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
3002 struct rte_cryptodev_sym_session *sess, unsigned data_len,
3003 unsigned digest_len)
3005 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3006 rte_crypto_op_free(op);
3010 /* Authentication Parameters */
3011 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3012 (m->data_off + data_len);
3013 op->sym->auth.digest.phys_addr =
3014 rte_pktmbuf_mtophys_offset(m, data_len);
3015 op->sym->auth.digest.length = digest_len;
3016 op->sym->auth.aad.data = snow3g_iv;
3017 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
3019 /* Cipher Parameters */
3020 op->sym->cipher.iv.data = snow3g_iv;
3021 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
3023 /* Data lengths/offsets Parameters */
3024 op->sym->auth.data.offset = 0;
3025 op->sym->auth.data.length = data_len << 3;
3027 op->sym->cipher.data.offset = 0;
3028 op->sym->cipher.data.length = data_len << 3;
3035 static inline struct rte_crypto_op *
3036 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
3038 struct rte_cryptodev_sym_session *sess,
3041 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3042 rte_crypto_op_free(op);
3046 /* Cipher Parameters */
3047 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
3048 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
3049 rte_memcpy(op->sym->cipher.iv.data, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3050 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
3052 op->sym->cipher.data.offset = SNOW3G_CIPHER_IV_LENGTH;
3053 op->sym->cipher.data.length = data_len << 3;
3061 static inline struct rte_crypto_op *
3062 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3064 struct rte_cryptodev_sym_session *sess,
3066 unsigned digest_len)
3068 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3069 rte_crypto_op_free(op);
3073 /* Authentication Parameters */
3075 op->sym->auth.digest.data =
3076 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3078 op->sym->auth.digest.phys_addr =
3079 rte_pktmbuf_mtophys_offset(m, data_len +
3080 SNOW3G_CIPHER_IV_LENGTH);
3081 op->sym->auth.digest.length = digest_len;
3082 op->sym->auth.aad.data = rte_pktmbuf_mtod(m, uint8_t *);
3083 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
3084 rte_memcpy(op->sym->auth.aad.data, snow3g_iv,
3085 SNOW3G_CIPHER_IV_LENGTH);
3086 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
3088 /* Data lengths/offsets Parameters */
3089 op->sym->auth.data.offset = SNOW3G_CIPHER_IV_LENGTH;
3090 op->sym->auth.data.length = data_len << 3;
3098 static inline struct rte_crypto_op *
3099 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3100 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3101 unsigned int digest_len, enum chain_mode chain __rte_unused)
3103 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3104 rte_crypto_op_free(op);
3108 /* Authentication Parameters */
3109 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3110 (m->data_off + data_len);
3111 op->sym->auth.digest.phys_addr =
3112 rte_pktmbuf_mtophys_offset(m, data_len);
3113 op->sym->auth.digest.length = digest_len;
3115 /* Cipher Parameters */
3116 op->sym->cipher.iv.data = triple_des_iv;
3117 op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
3119 /* Data lengths/offsets Parameters */
3120 op->sym->auth.data.offset = 0;
3121 op->sym->auth.data.length = data_len;
3123 op->sym->cipher.data.offset = 0;
3124 op->sym->cipher.data.length = data_len;
3131 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3132 * same time, i.e. as they're not dereferenced there's no need to wait until
3133 * finished with to re-use */
3134 #define NUM_MBUF_SETS 8
3137 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3138 struct perf_test_params *pparams)
3140 uint16_t i, k, l, m;
3142 uint16_t ops_unused = 0;
3144 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3145 uint64_t processed = 0, failed_polls = 0, retries = 0;
3146 uint64_t tsc_start = 0, tsc_end = 0;
3148 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3150 struct rte_crypto_op *ops[pparams->burst_size];
3151 struct rte_crypto_op *proc_ops[pparams->burst_size];
3153 struct rte_mbuf *mbufs[pparams->burst_size * 8];
3155 struct crypto_testsuite_params *ts_params = &testsuite_params;
3157 static struct rte_cryptodev_sym_session *sess;
3159 if (rte_cryptodev_count() == 0) {
3160 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3164 /* Create Crypto session*/
3165 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
3166 pparams->chain, pparams->cipher_algo,
3167 pparams->cipher_key_length, pparams->auth_algo);
3168 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3170 /* Generate a burst of crypto operations */
3171 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3172 mbufs[i] = test_perf_create_pktmbuf(
3176 if (mbufs[i] == NULL) {
3177 printf("\nFailed to get mbuf - freeing the rest.\n");
3178 for (k = 0; k < i; k++)
3179 rte_pktmbuf_free(mbufs[k]);
3183 /* Make room for Digest and IV in mbuf */
3184 if (pparams->chain != CIPHER_ONLY)
3185 rte_pktmbuf_append(mbufs[i], digest_length);
3186 rte_pktmbuf_prepend(mbufs[i], AES_CIPHER_IV_LENGTH);
3190 tsc_start = rte_rdtsc_precise();
3192 while (total_enqueued < pparams->total_operations) {
3193 uint16_t burst_size =
3194 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3195 pparams->burst_size : pparams->total_operations-total_enqueued;
3196 uint16_t ops_needed = burst_size-ops_unused;
3198 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3199 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3200 printf("\nFailed to alloc enough ops, finish dequeuing "
3201 "and free ops below.");
3203 for (i = 0; i < ops_needed; i++)
3204 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3205 mbufs[i + (pparams->burst_size *
3206 (j % NUM_MBUF_SETS))],
3207 sess, pparams->buf_size, digest_length,
3211 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3212 queue_id, ops, burst_size);
3214 if (burst_enqueued < burst_size)
3217 ops_unused = burst_size-burst_enqueued;
3218 total_enqueued += burst_enqueued;
3222 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3223 proc_ops, pparams->burst_size);
3224 if (burst_dequeued == 0)
3227 processed += burst_dequeued;
3229 for (l = 0; l < burst_dequeued; l++)
3230 rte_crypto_op_free(proc_ops[l]);
3235 /* Dequeue any operations still in the crypto device */
3236 while (processed < pparams->total_operations) {
3237 /* Sending 0 length burst to flush sw crypto device */
3238 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3241 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3242 proc_ops, pparams->burst_size);
3243 if (burst_dequeued == 0)
3246 processed += burst_dequeued;
3248 for (m = 0; m < burst_dequeued; m++)
3249 rte_crypto_op_free(proc_ops[m]);
3253 tsc_end = rte_rdtsc_precise();
3255 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3256 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3258 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3259 throughput, retries, failed_polls);
3261 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3262 rte_pktmbuf_free(mbufs[i]);
3263 rte_cryptodev_sym_session_free(dev_id, sess);
3266 return TEST_SUCCESS;
3271 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3272 struct perf_test_params *pparams)
3274 uint16_t i, k, l, m;
3276 uint16_t ops_unused = 0;
3277 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3278 uint64_t processed = 0, failed_polls = 0, retries = 0;
3279 uint64_t tsc_start = 0, tsc_end = 0;
3281 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3283 struct rte_crypto_op *ops[pparams->burst_size];
3284 struct rte_crypto_op *proc_ops[pparams->burst_size];
3286 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3288 struct crypto_testsuite_params *ts_params = &testsuite_params;
3290 static struct rte_cryptodev_sym_session *sess;
3292 if (rte_cryptodev_count() == 0) {
3293 printf("\nNo crypto devices found. Is PMD build configured?\n");
3294 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3298 /* Create Crypto session*/
3299 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3300 pparams->chain, pparams->cipher_algo,
3301 pparams->cipher_key_length, pparams->auth_algo);
3302 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3304 /* Generate a burst of crypto operations */
3305 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3307 * Buffer size + iv/aad len is allocated, for perf tests they
3308 * are equal + digest len.
3310 mbufs[i] = test_perf_create_pktmbuf(
3312 pparams->buf_size + SNOW3G_CIPHER_IV_LENGTH +
3315 if (mbufs[i] == NULL) {
3316 printf("\nFailed to get mbuf - freeing the rest.\n");
3317 for (k = 0; k < i; k++)
3318 rte_pktmbuf_free(mbufs[k]);
3324 tsc_start = rte_rdtsc_precise();
3326 while (total_enqueued < pparams->total_operations) {
3327 uint16_t burst_size =
3328 (total_enqueued+pparams->burst_size)
3329 <= pparams->total_operations ?
3330 pparams->burst_size : pparams->total_operations-total_enqueued;
3331 uint16_t ops_needed = burst_size-ops_unused;
3332 /* Handle the last burst correctly */
3333 uint16_t op_offset = pparams->burst_size - burst_size;
3336 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3337 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3338 ops+op_offset, ops_needed)) {
3339 printf("\nFailed to alloc enough ops.");
3340 /*Don't exit, dequeue, more ops should become available*/
3342 for (i = 0; i < ops_needed; i++) {
3343 if (pparams->chain == HASH_ONLY)
3345 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3347 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3349 pparams->buf_size, digest_length);
3350 else if (pparams->chain == CIPHER_ONLY)
3352 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3354 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3363 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3364 ops+op_offset, burst_size);
3366 if (burst_enqueued < burst_size)
3369 ops_unused = burst_size-burst_enqueued;
3370 total_enqueued += burst_enqueued;
3374 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3375 proc_ops, pparams->burst_size);
3376 if (burst_dequeued == 0) {
3379 processed += burst_dequeued;
3380 for (l = 0; l < burst_dequeued; l++)
3381 rte_crypto_op_free(proc_ops[l]);
3386 /* Dequeue any operations still in the crypto device */
3387 while (processed < pparams->total_operations) {
3388 /* Sending 0 length burst to flush sw crypto device */
3389 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3392 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3393 proc_ops, pparams->burst_size);
3394 if (burst_dequeued == 0)
3397 processed += burst_dequeued;
3398 for (m = 0; m < burst_dequeued; m++)
3399 rte_crypto_op_free(proc_ops[m]);
3403 tsc_end = rte_rdtsc_precise();
3405 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3406 double cycles_burst = (double) (tsc_end - tsc_start) /
3407 (double) processed * pparams->burst_size;
3408 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3409 double cycles_B = cycles_buff / pparams->buf_size;
3410 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3412 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3413 /* Cycle count misleading on HW devices for this test, so don't print */
3414 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3415 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3416 pparams->buf_size, ops_s/1000000,
3417 throughput, retries, failed_polls);
3419 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3420 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3421 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3422 cycles_buff, cycles_B, retries, failed_polls);
3425 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3426 rte_pktmbuf_free(mbufs[i]);
3427 rte_cryptodev_sym_session_free(dev_id, sess);
3430 return TEST_SUCCESS;
3434 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3435 struct perf_test_params *pparams)
3437 uint16_t i, k, l, m;
3439 uint16_t ops_unused = 0;
3441 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3442 uint64_t processed = 0, failed_polls = 0, retries = 0;
3443 uint64_t tsc_start = 0, tsc_end = 0;
3445 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3447 struct rte_crypto_op *ops[pparams->burst_size];
3448 struct rte_crypto_op *proc_ops[pparams->burst_size];
3450 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3452 struct crypto_testsuite_params *ts_params = &testsuite_params;
3454 static struct rte_cryptodev_sym_session *sess;
3456 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3457 (struct rte_crypto_op *, struct rte_mbuf *,
3458 struct rte_cryptodev_sym_session *,
3459 unsigned int, unsigned int,
3462 switch (pparams->cipher_algo) {
3463 case RTE_CRYPTO_CIPHER_3DES_CBC:
3464 case RTE_CRYPTO_CIPHER_3DES_CTR:
3465 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3467 case RTE_CRYPTO_CIPHER_AES_CBC:
3468 case RTE_CRYPTO_CIPHER_AES_CTR:
3469 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3471 case RTE_CRYPTO_CIPHER_AES_GCM:
3472 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3478 if (rte_cryptodev_count() == 0) {
3479 printf("\nNo crypto devices found. Is PMD build configured?\n");
3483 /* Create Crypto session*/
3484 sess = test_perf_create_openssl_session(ts_params->dev_id,
3485 pparams->chain, pparams->cipher_algo,
3486 pparams->cipher_key_length, pparams->auth_algo);
3487 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3489 /* Generate a burst of crypto operations */
3490 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3491 mbufs[i] = test_perf_create_pktmbuf(
3495 if (mbufs[i] == NULL) {
3496 printf("\nFailed to get mbuf - freeing the rest.\n");
3497 for (k = 0; k < i; k++)
3498 rte_pktmbuf_free(mbufs[k]);
3503 tsc_start = rte_rdtsc_precise();
3505 while (total_enqueued < pparams->total_operations) {
3506 uint16_t burst_size =
3507 total_enqueued + pparams->burst_size <=
3508 pparams->total_operations ? pparams->burst_size :
3509 pparams->total_operations - total_enqueued;
3510 uint16_t ops_needed = burst_size - ops_unused;
3512 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3513 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3514 printf("\nFailed to alloc enough ops, finish dequeuing "
3515 "and free ops below.");
3517 for (i = 0; i < ops_needed; i++)
3518 ops[i] = test_perf_set_crypto_op(ops[i],
3519 mbufs[i + (pparams->burst_size *
3520 (j % NUM_MBUF_SETS))],
3521 sess, pparams->buf_size, digest_length,
3525 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3526 queue_id, ops, burst_size);
3528 if (burst_enqueued < burst_size)
3531 ops_unused = burst_size - burst_enqueued;
3532 total_enqueued += burst_enqueued;
3536 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3537 proc_ops, pparams->burst_size);
3538 if (burst_dequeued == 0)
3541 processed += burst_dequeued;
3543 for (l = 0; l < burst_dequeued; l++)
3544 rte_crypto_op_free(proc_ops[l]);
3549 /* Dequeue any operations still in the crypto device */
3550 while (processed < pparams->total_operations) {
3551 /* Sending 0 length burst to flush sw crypto device */
3552 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3555 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3556 proc_ops, pparams->burst_size);
3557 if (burst_dequeued == 0)
3560 processed += burst_dequeued;
3562 for (m = 0; m < burst_dequeued; m++)
3563 rte_crypto_op_free(proc_ops[m]);
3567 tsc_end = rte_rdtsc_precise();
3569 double ops_s = ((double)processed / (tsc_end - tsc_start))
3571 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3574 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3575 ops_s / 1000000, throughput, retries, failed_polls);
3577 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3578 rte_pktmbuf_free(mbufs[i]);
3579 rte_cryptodev_sym_session_free(dev_id, sess);
3582 return TEST_SUCCESS;
3586 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3587 struct perf_test_params *pparams)
3589 uint16_t i, k, l, m;
3591 uint16_t ops_unused = 0;
3592 uint16_t burst_size;
3593 uint16_t ops_needed;
3595 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3596 uint64_t processed = 0, failed_polls = 0, retries = 0;
3597 uint64_t tsc_start = 0, tsc_end = 0;
3599 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3601 struct rte_crypto_op *ops[pparams->burst_size];
3602 struct rte_crypto_op *proc_ops[pparams->burst_size];
3604 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3606 struct crypto_testsuite_params *ts_params = &testsuite_params;
3608 static struct rte_cryptodev_sym_session *sess;
3610 if (rte_cryptodev_count() == 0) {
3611 printf("\nNo crypto devices found. Is PMD build configured?\n");
3615 /* Create Crypto session*/
3616 sess = test_perf_create_armv8_session(ts_params->dev_id,
3617 pparams->chain, pparams->cipher_algo,
3618 pparams->cipher_key_length, pparams->auth_algo);
3619 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3621 /* Generate a burst of crypto operations */
3622 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3623 mbufs[i] = test_perf_create_pktmbuf(
3627 if (mbufs[i] == NULL) {
3628 printf("\nFailed to get mbuf - freeing the rest.\n");
3629 for (k = 0; k < i; k++)
3630 rte_pktmbuf_free(mbufs[k]);
3635 tsc_start = rte_rdtsc();
3637 while (total_enqueued < pparams->total_operations) {
3638 if ((total_enqueued + pparams->burst_size) <=
3639 pparams->total_operations)
3640 burst_size = pparams->burst_size;
3642 burst_size = pparams->total_operations - total_enqueued;
3644 ops_needed = burst_size - ops_unused;
3646 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3647 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3648 printf("\nFailed to alloc enough ops, finish dequeuing "
3649 "and free ops below.");
3651 for (i = 0; i < ops_needed; i++)
3652 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3653 mbufs[i + (pparams->burst_size *
3654 (j % NUM_MBUF_SETS))], sess,
3655 pparams->buf_size, digest_length,
3659 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3660 queue_id, ops, burst_size);
3662 if (burst_enqueued < burst_size)
3665 ops_unused = burst_size - burst_enqueued;
3666 total_enqueued += burst_enqueued;
3670 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3671 proc_ops, pparams->burst_size);
3672 if (burst_dequeued == 0)
3675 processed += burst_dequeued;
3677 for (l = 0; l < burst_dequeued; l++)
3678 rte_crypto_op_free(proc_ops[l]);
3683 /* Dequeue any operations still in the crypto device */
3684 while (processed < pparams->total_operations) {
3685 /* Sending 0 length burst to flush sw crypto device */
3686 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3689 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3690 proc_ops, pparams->burst_size);
3691 if (burst_dequeued == 0)
3694 processed += burst_dequeued;
3696 for (m = 0; m < burst_dequeued; m++)
3697 rte_crypto_op_free(proc_ops[m]);
3701 tsc_end = rte_rdtsc();
3703 double ops_s = ((double)processed / (tsc_end - tsc_start))
3705 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3708 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3709 ops_s / 1000000, throughput, retries, failed_polls);
3711 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3712 rte_pktmbuf_free(mbufs[i]);
3715 return TEST_SUCCESS;
3720 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3721 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3722 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3724 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3725 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3726 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3728 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3729 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3730 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3733 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3735 unsigned total_operations = 1000000;
3736 unsigned burst_size = 32;
3737 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3740 struct perf_test_params params_set[] = {
3742 .chain = CIPHER_ONLY,
3743 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3744 .cipher_key_length = 16,
3745 .auth_algo = RTE_CRYPTO_AUTH_NULL
3748 .chain = CIPHER_HASH,
3749 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3750 .cipher_key_length = 16,
3751 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3754 .chain = CIPHER_HASH,
3756 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3757 .cipher_key_length = 16,
3758 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3761 .chain = CIPHER_HASH,
3763 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3764 .cipher_key_length = 16,
3765 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3768 .chain = CIPHER_HASH,
3770 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3771 .cipher_key_length = 32,
3772 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3775 .chain = CIPHER_HASH,
3777 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3778 .cipher_key_length = 32,
3779 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3782 .chain = CIPHER_HASH,
3784 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3785 .cipher_key_length = 32,
3786 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3790 for (i = 0; i < RTE_DIM(params_set); i++) {
3792 params_set[i].total_operations = total_operations;
3793 params_set[i].burst_size = burst_size;
3794 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3795 " burst_size: %d ops\n",
3796 chain_mode_name(params_set[i].chain),
3797 cipher_algo_name(params_set[i].cipher_algo),
3798 auth_algo_name(params_set[i].auth_algo),
3799 params_set[i].cipher_key_length,
3801 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3802 "Retries\tEmptyPolls\n");
3803 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3804 params_set[i].buf_size = buf_lengths[j];
3805 test_perf_aes_sha(testsuite_params.dev_id, 0,
3813 test_perf_snow3G_vary_pkt_size(void)
3815 unsigned total_operations = 1000000;
3818 uint16_t burst_sizes[] = { 64 };
3819 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3821 struct perf_test_params params_set[] = {
3823 .chain = CIPHER_ONLY,
3824 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3825 .cipher_key_length = 16,
3826 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3830 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3831 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3832 .cipher_key_length = 16
3836 printf("\n\nStart %s.", __func__);
3837 printf("\nTest to measure max throughput at various pkt sizes.");
3838 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3839 " so cycle cost not relevant (n/a displayed).");
3841 for (i = 0; i < RTE_DIM(params_set); i++) {
3843 params_set[i].total_operations = total_operations;
3844 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3845 printf("\nOn %s dev%u qp%u, %s, "
3846 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3847 pmd_name(gbl_cryptodev_perftest_devtype),
3848 testsuite_params.dev_id, 0,
3849 chain_mode_name(params_set[i].chain),
3850 cipher_algo_name(params_set[i].cipher_algo),
3851 auth_algo_name(params_set[i].auth_algo),
3854 params_set[i].burst_size = burst_sizes[k];
3855 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3856 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3857 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3859 params_set[i].buf_size = buf_lengths[j];
3861 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3870 test_perf_openssl_vary_pkt_size(void)
3872 unsigned int total_operations = 10000;
3873 unsigned int burst_size = { 64 };
3874 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3878 struct perf_test_params params_set[] = {
3880 .chain = CIPHER_HASH,
3882 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3883 .cipher_key_length = 16,
3884 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3887 .chain = CIPHER_HASH,
3889 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3890 .cipher_key_length = 24,
3891 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3894 .chain = CIPHER_HASH,
3896 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3897 .cipher_key_length = 16,
3898 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3901 .chain = CIPHER_HASH,
3903 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3904 .cipher_key_length = 32,
3905 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3908 .chain = CIPHER_HASH,
3910 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3911 .cipher_key_length = 16,
3912 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3915 .chain = CIPHER_HASH,
3917 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3918 .cipher_key_length = 24,
3919 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3922 .chain = CIPHER_HASH,
3924 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3925 .cipher_key_length = 16,
3926 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3930 for (i = 0; i < RTE_DIM(params_set); i++) {
3931 params_set[i].total_operations = total_operations;
3932 params_set[i].burst_size = burst_size;
3933 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3934 " burst_size: %d ops\n",
3935 chain_mode_name(params_set[i].chain),
3936 cipher_algo_name(params_set[i].cipher_algo),
3937 auth_algo_name(params_set[i].auth_algo),
3938 params_set[i].cipher_key_length,
3940 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3942 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3943 params_set[i].buf_size = buf_lengths[j];
3944 test_perf_openssl(testsuite_params.dev_id, 0,
3953 test_perf_openssl_vary_burst_size(void)
3955 unsigned int total_operations = 4096;
3956 uint16_t buf_lengths[] = { 40 };
3959 struct perf_test_params params_set[] = {
3961 .chain = CIPHER_HASH,
3963 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3964 .cipher_key_length = 16,
3965 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3968 .chain = CIPHER_HASH,
3970 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3971 .cipher_key_length = 24,
3972 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3975 .chain = CIPHER_HASH,
3977 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3978 .cipher_key_length = 16,
3979 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3982 .chain = CIPHER_HASH,
3984 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3985 .cipher_key_length = 32,
3986 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3989 .chain = CIPHER_HASH,
3991 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3992 .cipher_key_length = 16,
3993 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3996 .chain = CIPHER_HASH,
3998 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3999 .cipher_key_length = 24,
4000 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4003 .chain = CIPHER_HASH,
4005 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
4006 .cipher_key_length = 16,
4007 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
4011 printf("\n\nStart %s.", __func__);
4012 printf("\nThis Test measures the average IA cycle cost using a "
4013 "constant request(packet) size. ");
4014 printf("Cycle cost is only valid when indicators show device is not"
4015 " busy, i.e. Retries and EmptyPolls = 0");
4017 for (i = 0; i < RTE_DIM(params_set); i++) {
4019 params_set[i].total_operations = total_operations;
4021 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4022 params_set[i].buf_size = buf_lengths[j];
4023 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
4031 test_perf_armv8_vary_pkt_size(void)
4033 unsigned int total_operations = 100000;
4034 unsigned int burst_size = { 64 };
4035 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
4039 struct perf_test_params params_set[] = {
4041 .chain = CIPHER_HASH,
4043 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4044 .cipher_key_length = 16,
4045 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4048 .chain = HASH_CIPHER,
4050 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4051 .cipher_key_length = 16,
4052 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4055 .chain = CIPHER_HASH,
4057 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4058 .cipher_key_length = 16,
4059 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4062 .chain = HASH_CIPHER,
4064 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4065 .cipher_key_length = 16,
4066 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4070 for (i = 0; i < RTE_DIM(params_set); i++) {
4071 params_set[i].total_operations = total_operations;
4072 params_set[i].burst_size = burst_size;
4073 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4074 " burst_size: %d ops\n",
4075 chain_mode_name(params_set[i].chain),
4076 cipher_algo_name(params_set[i].cipher_algo),
4077 auth_algo_name(params_set[i].auth_algo),
4078 params_set[i].cipher_key_length,
4080 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4082 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4083 params_set[i].buf_size = buf_lengths[j];
4084 test_perf_armv8(testsuite_params.dev_id, 0,
4093 test_perf_armv8_vary_burst_size(void)
4095 unsigned int total_operations = 4096;
4096 uint16_t buf_lengths[] = { 64 };
4099 struct perf_test_params params_set[] = {
4101 .chain = CIPHER_HASH,
4103 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4104 .cipher_key_length = 16,
4105 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4108 .chain = HASH_CIPHER,
4110 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4111 .cipher_key_length = 16,
4112 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4115 .chain = CIPHER_HASH,
4117 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4118 .cipher_key_length = 16,
4119 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4122 .chain = HASH_CIPHER,
4124 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4125 .cipher_key_length = 16,
4126 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4130 printf("\n\nStart %s.", __func__);
4131 printf("\nThis Test measures the average IA cycle cost using a "
4132 "constant request(packet) size. ");
4133 printf("Cycle cost is only valid when indicators show device is "
4134 "not busy, i.e. Retries and EmptyPolls = 0");
4136 for (i = 0; i < RTE_DIM(params_set); i++) {
4138 params_set[i].total_operations = total_operations;
4140 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4141 params_set[i].buf_size = buf_lengths[j];
4142 test_perf_armv8_optimise_cyclecount(¶ms_set[i]);
4150 test_perf_aes_cbc_vary_burst_size(void)
4152 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4156 static struct rte_cryptodev_sym_session *
4157 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4159 static struct rte_cryptodev_sym_session *sess;
4160 struct rte_crypto_sym_xform cipher_xform = { 0 };
4161 struct rte_crypto_sym_xform auth_xform = { 0 };
4163 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
4164 uint8_t auth_key[pparams->session_attrs->key_auth_len];
4166 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
4167 pparams->session_attrs->key_cipher_len);
4168 memcpy(auth_key, pparams->session_attrs->key_auth_data,
4169 pparams->session_attrs->key_auth_len);
4171 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
4172 cipher_xform.next = NULL;
4174 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
4175 cipher_xform.cipher.op = pparams->session_attrs->cipher;
4176 cipher_xform.cipher.key.data = cipher_key;
4177 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
4179 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
4180 auth_xform.next = NULL;
4182 auth_xform.auth.op = pparams->session_attrs->auth;
4183 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
4185 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
4186 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
4189 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4190 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
4191 cipher_xform.next = &auth_xform;
4192 sess = rte_cryptodev_sym_session_create(dev_id,
4195 auth_xform.next = &cipher_xform;
4196 sess = rte_cryptodev_sym_session_create(dev_id,
4203 static inline struct rte_crypto_op *
4204 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4205 struct rte_cryptodev_sym_session *sess,
4206 struct crypto_params *m_hlp,
4207 struct perf_test_params *params)
4209 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4210 rte_crypto_op_free(op);
4214 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len,
4217 op->sym->auth.digest.data = m_hlp->digest;
4218 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4220 params->symmetric_op->aad_len +
4222 params->symmetric_op->p_len);
4224 op->sym->auth.digest.length = params->symmetric_op->t_len;
4226 op->sym->auth.aad.data = m_hlp->aad;
4227 op->sym->auth.aad.length = params->symmetric_op->aad_len;
4228 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys_offset(
4232 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
4233 params->symmetric_op->aad_len);
4235 op->sym->cipher.iv.data = m_hlp->iv;
4236 rte_memcpy(op->sym->cipher.iv.data, params->symmetric_op->iv_data,
4237 params->symmetric_op->iv_len);
4238 if (params->symmetric_op->iv_len == 12)
4239 op->sym->cipher.iv.data[15] = 1;
4241 op->sym->cipher.iv.length = params->symmetric_op->iv_len;
4243 op->sym->auth.data.offset =
4244 iv_pad_len + params->symmetric_op->aad_len;
4245 op->sym->auth.data.length = params->symmetric_op->p_len;
4247 op->sym->cipher.data.offset =
4248 iv_pad_len + params->symmetric_op->aad_len;
4249 op->sym->cipher.data.length = params->symmetric_op->p_len;
4256 static struct rte_mbuf *
4257 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4258 struct perf_test_params *params,
4259 unsigned buf_sz, struct crypto_params *m_hlp)
4261 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4262 uint16_t iv_pad_len =
4263 ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, 16);
4264 uint16_t aad_len = params->symmetric_op->aad_len;
4265 uint16_t digest_size = params->symmetric_op->t_len;
4268 p = rte_pktmbuf_append(m, aad_len);
4270 rte_pktmbuf_free(m);
4273 m_hlp->aad = (uint8_t *)p;
4275 p = rte_pktmbuf_append(m, iv_pad_len);
4277 rte_pktmbuf_free(m);
4280 m_hlp->iv = (uint8_t *)p;
4282 p = rte_pktmbuf_append(m, buf_sz);
4284 rte_pktmbuf_free(m);
4287 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4289 p = rte_pktmbuf_append(m, digest_size);
4291 rte_pktmbuf_free(m);
4294 m_hlp->digest = (uint8_t *)p;
4300 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4301 struct perf_test_params *pparams, uint32_t test_ops)
4304 struct crypto_testsuite_params *ts_params = &testsuite_params;
4305 struct rte_cryptodev_sym_session *sess;
4306 struct rte_crypto_op *ops[pparams->burst_size];
4307 struct rte_crypto_op *proc_ops[pparams->burst_size];
4308 uint32_t total_operations = pparams->total_operations;
4310 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4311 uint64_t processed = 0, failed_polls = 0, retries = 0;
4312 uint64_t tsc_start = 0, tsc_end = 0;
4314 uint16_t i = 0, l = 0, m = 0;
4315 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4316 uint16_t ops_unused = 0;
4318 struct rte_mbuf *mbufs[burst];
4319 struct crypto_params m_hlp[burst];
4321 if (rte_cryptodev_count() == 0) {
4322 printf("\nNo crypto devices available. "
4323 "Is kernel driver loaded?\n");
4327 sess = test_perf_create_session(dev_id, pparams);
4328 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4330 for (i = 0; i < burst; i++) {
4331 mbufs[i] = test_perf_create_pktmbuf_fill(
4333 pparams, pparams->symmetric_op->p_len,
4338 total_operations = test_ops;
4340 tsc_start = rte_rdtsc_precise();
4341 while (total_enqueued < total_operations) {
4342 uint16_t burst_size =
4343 total_enqueued+pparams->burst_size <= total_operations ?
4344 pparams->burst_size : total_operations-total_enqueued;
4345 uint16_t ops_needed = burst_size-ops_unused;
4347 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4348 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4349 printf("\nFailed to alloc enough ops, "
4350 "finish dequeuing");
4352 for (i = 0; i < ops_needed; i++)
4353 ops[i] = perf_gcm_set_crypto_op(ops[i],
4354 mbufs[i + (pparams->burst_size *
4355 (j % NUM_MBUF_SETS))],
4356 sess, &m_hlp[i + (pparams->burst_size *
4357 (j % NUM_MBUF_SETS))], pparams);
4360 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4361 queue_id, ops, burst_size);
4363 if (burst_enqueued < burst_size)
4366 ops_unused = burst_size-burst_enqueued;
4367 total_enqueued += burst_enqueued;
4371 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4372 proc_ops, pparams->burst_size);
4373 if (burst_dequeued == 0)
4376 processed += burst_dequeued;
4378 for (l = 0; l < burst_dequeued; l++)
4379 rte_crypto_op_free(proc_ops[l]);
4385 /* Dequeue any operations still in the crypto device */
4386 while (processed < total_operations) {
4387 /* Sending 0 length burst to flush sw crypto device */
4388 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4391 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4392 proc_ops, pparams->burst_size);
4393 if (burst_dequeued == 0)
4396 processed += burst_dequeued;
4398 for (m = 0; m < burst_dequeued; m++) {
4400 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP
4401 (pparams->symmetric_op->iv_len, 16);
4402 uint8_t *pkt = rte_pktmbuf_mtod(
4403 proc_ops[m]->sym->m_src,
4406 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4407 pparams->symmetric_op->c_data,
4409 pparams->symmetric_op->aad_len,
4410 pparams->symmetric_op->c_len,
4411 "GCM Ciphertext data not as expected");
4413 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4414 pparams->symmetric_op->t_data,
4416 pparams->symmetric_op->aad_len +
4417 pparams->symmetric_op->c_len,
4418 pparams->symmetric_op->t_len,
4419 "GCM MAC data not as expected");
4422 rte_crypto_op_free(proc_ops[m]);
4427 tsc_end = rte_rdtsc_precise();
4429 double ops_s = ((double)processed / (tsc_end - tsc_start))
4431 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4435 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4436 pparams->symmetric_op->p_len,
4437 ops_s/1000000, throughput, retries, failed_polls);
4440 for (i = 0; i < burst; i++)
4441 rte_pktmbuf_free(mbufs[i]);
4442 rte_cryptodev_sym_session_free(dev_id, sess);
4448 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4450 uint16_t i, j, k, loops = 1;
4452 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4454 static const struct cryptodev_perf_test_data *gcm_tests[] = {
4455 &AES_GCM_128_12IV_0AAD
4458 if (continual_buf_len)
4459 loops = continual_size;
4461 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4463 const unsigned burst_size = 32;
4465 struct symmetric_op ops_set[TEST_CASES_GCM];
4466 struct perf_test_params params_set[TEST_CASES_GCM];
4467 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4468 static const struct cryptodev_perf_test_data *gcm_test;
4470 for (i = 0; i < TEST_CASES_GCM; ++i) {
4472 gcm_test = gcm_tests[i];
4474 session_attrs[i].cipher =
4475 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
4476 session_attrs[i].cipher_algorithm =
4477 RTE_CRYPTO_CIPHER_AES_GCM;
4478 session_attrs[i].key_cipher_data =
4480 session_attrs[i].key_cipher_len =
4482 session_attrs[i].auth_algorithm =
4483 RTE_CRYPTO_AUTH_AES_GCM;
4484 session_attrs[i].auth =
4485 RTE_CRYPTO_AUTH_OP_GENERATE;
4486 session_attrs[i].key_auth_data = NULL;
4487 session_attrs[i].key_auth_len = 0;
4488 session_attrs[i].digest_len =
4489 gcm_test->auth_tag.len;
4491 ops_set[i].aad_data = gcm_test->aad.data;
4492 ops_set[i].aad_len = gcm_test->aad.len;
4493 ops_set[i].iv_data = gcm_test->iv.data;
4494 ops_set[i].iv_len = gcm_test->iv.len;
4495 ops_set[i].p_data = gcm_test->plaintext.data;
4496 ops_set[i].p_len = buf_lengths[i];
4497 ops_set[i].c_data = gcm_test->ciphertext.data;
4498 ops_set[i].c_len = buf_lengths[i];
4499 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4500 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4502 params_set[i].chain = CIPHER_HASH;
4503 params_set[i].session_attrs = &session_attrs[i];
4504 params_set[i].symmetric_op = &ops_set[i];
4505 if (continual_buf_len)
4506 params_set[i].total_operations = 0xFFFFFF;
4508 params_set[i].total_operations = 1000000;
4510 params_set[i].burst_size = burst_size;
4514 if (continual_buf_len)
4515 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4516 " burst size: %u", "AES_GCM", "AES_GCM",
4517 gcm_test->key.len << 3, burst_size);
4519 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4521 if (!continual_buf_len) {
4522 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4523 " burst size: %u", "AES_GCM", "AES_GCM",
4524 gcm_test->key.len << 3, burst_size);
4525 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4526 " Retries\tEmptyPolls");
4529 uint16_t len = RTE_DIM(buf_lengths);
4532 if (continual_buf_len) {
4533 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4534 if (buf_lengths[k] == continual_buf_len) {
4540 for (j = p; j < len; ++j) {
4542 params_set[i].symmetric_op->c_len = buf_lengths[j];
4543 params_set[i].symmetric_op->p_len = buf_lengths[j];
4545 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4546 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4548 /* Run is twice, one for encryption/hash checks,
4551 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4555 for (k = 0; k < loops; k++) {
4556 if (continual_buf_len)
4557 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4558 "Throughput(Gbps)\t"
4559 "Retries\tEmptyPolls");
4560 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4563 if (continual_buf_len)
4564 printf("\n\nCompleted loop %i of %i ...",
4574 static int test_cryptodev_perf_AES_GCM(void)
4576 return test_perf_AES_GCM(0, 0);
4579 * This function calls AES GCM performance tests providing
4580 * size of packet as an argument. If size of packet is not
4581 * in the buf_lengths array, all sizes will be used
4583 static int test_continual_perf_AES_GCM(void)
4585 return test_perf_AES_GCM(1024, 10);
4589 test_perf_continual_performance_test(void)
4591 unsigned int total_operations = 0xFFFFFF;
4592 unsigned int total_loops = 10;
4593 unsigned int burst_size = 32;
4596 struct perf_test_params params_set = {
4597 .total_operations = total_operations,
4598 .burst_size = burst_size,
4601 .chain = CIPHER_HASH,
4603 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4604 .cipher_key_length = 16,
4605 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4608 for (i = 1; i <= total_loops; ++i) {
4609 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4610 " burst_size: %d ops\n",
4611 chain_mode_name(params_set.chain),
4612 cipher_algo_name(params_set.cipher_algo),
4613 auth_algo_name(params_set.auth_algo),
4614 params_set.cipher_key_length,
4616 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4617 "Retries\tEmptyPolls\n");
4618 test_perf_aes_sha(testsuite_params.dev_id, 0,
4620 printf("\nCompleted loop %i of %i ...", i, total_loops);
4625 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4626 .suite_name = "Crypto Device Continual Performance Test",
4627 .setup = testsuite_setup,
4628 .teardown = testsuite_teardown,
4629 .unit_test_cases = {
4630 TEST_CASE_ST(ut_setup, ut_teardown,
4631 test_perf_continual_performance_test),
4632 TEST_CASE_ST(ut_setup, ut_teardown,
4633 test_continual_perf_AES_GCM),
4634 TEST_CASES_END() /**< NULL terminate unit test array */
4638 static struct unit_test_suite cryptodev_testsuite = {
4639 .suite_name = "Crypto Device Unit Test Suite",
4640 .setup = testsuite_setup,
4641 .teardown = testsuite_teardown,
4642 .unit_test_cases = {
4643 TEST_CASE_ST(ut_setup, ut_teardown,
4644 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4645 TEST_CASE_ST(ut_setup, ut_teardown,
4646 test_cryptodev_perf_AES_GCM),
4647 TEST_CASE_ST(ut_setup, ut_teardown,
4648 test_perf_aes_cbc_vary_burst_size),
4649 TEST_CASES_END() /**< NULL terminate unit test array */
4653 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = {
4654 .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4655 .setup = testsuite_setup,
4656 .teardown = testsuite_teardown,
4657 .unit_test_cases = {
4658 TEST_CASE_ST(ut_setup, ut_teardown,
4659 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4660 TEST_CASES_END() /**< NULL terminate unit test array */
4664 static struct unit_test_suite cryptodev_gcm_testsuite = {
4665 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4666 .setup = testsuite_setup,
4667 .teardown = testsuite_teardown,
4668 .unit_test_cases = {
4669 TEST_CASE_ST(ut_setup, ut_teardown,
4670 test_cryptodev_perf_AES_GCM),
4671 TEST_CASES_END() /**< NULL terminate unit test array */
4675 static struct unit_test_suite cryptodev_aes_testsuite = {
4676 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4677 .setup = testsuite_setup,
4678 .teardown = testsuite_teardown,
4679 .unit_test_cases = {
4680 TEST_CASE_ST(ut_setup, ut_teardown,
4681 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4682 TEST_CASES_END() /**< NULL terminate unit test array */
4686 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4687 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4688 .setup = testsuite_setup,
4689 .teardown = testsuite_teardown,
4690 .unit_test_cases = {
4691 TEST_CASE_ST(ut_setup, ut_teardown,
4692 test_perf_snow3G_vary_pkt_size),
4693 TEST_CASE_ST(ut_setup, ut_teardown,
4694 test_perf_snow3G_vary_burst_size),
4695 TEST_CASES_END() /**< NULL terminate unit test array */
4699 static struct unit_test_suite cryptodev_openssl_testsuite = {
4700 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4701 .setup = testsuite_setup,
4702 .teardown = testsuite_teardown,
4703 .unit_test_cases = {
4704 TEST_CASE_ST(ut_setup, ut_teardown,
4705 test_perf_openssl_vary_pkt_size),
4706 TEST_CASE_ST(ut_setup, ut_teardown,
4707 test_perf_openssl_vary_burst_size),
4708 TEST_CASES_END() /**< NULL terminate unit test array */
4712 static struct unit_test_suite cryptodev_armv8_testsuite = {
4713 .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4714 .setup = testsuite_setup,
4715 .teardown = testsuite_teardown,
4716 .unit_test_cases = {
4717 TEST_CASE_ST(ut_setup, ut_teardown,
4718 test_perf_armv8_vary_pkt_size),
4719 TEST_CASE_ST(ut_setup, ut_teardown,
4720 test_perf_armv8_vary_burst_size),
4721 TEST_CASES_END() /**< NULL terminate unit test array */
4726 perftest_aesni_gcm_cryptodev(void)
4728 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4730 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4734 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4736 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4738 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4742 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4744 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4746 return unit_test_suite_runner(&cryptodev_testsuite);
4750 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4752 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4754 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4758 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4760 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4762 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4766 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4768 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4770 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4774 perftest_qat_continual_cryptodev(void)
4776 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4778 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4782 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4784 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_ARMV8_PMD;
4786 return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4790 perftest_dpaa2_sec_cryptodev(void)
4792 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD;
4794 return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4797 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4798 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4799 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4800 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4801 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4802 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4803 perftest_openssl_cryptodev);
4804 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4805 perftest_qat_continual_cryptodev);
4806 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4807 perftest_sw_armv8_cryptodev);
4808 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4809 perftest_dpaa2_sec_cryptodev);