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_mbuf *
161 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
162 static inline struct rte_crypto_op *
163 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
164 struct rte_cryptodev_sym_session *sess, unsigned data_len,
165 unsigned digest_len);
166 static inline struct rte_crypto_op *
167 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
168 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
169 unsigned int digest_len);
170 static inline struct rte_crypto_op *
171 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
172 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
173 unsigned int digest_len);
174 static inline struct rte_crypto_op *
175 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
176 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
177 unsigned int digest_len);
178 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
181 static const char *chain_mode_name(enum chain_mode mode)
184 case CIPHER_HASH: return "cipher_hash"; break;
185 case HASH_CIPHER: return "hash_cipher"; break;
186 case CIPHER_ONLY: return "cipher_only"; break;
187 case HASH_ONLY: return "hash_only"; break;
188 default: return ""; break;
192 static const char *pmd_name(enum rte_cryptodev_type pmd)
195 case RTE_CRYPTODEV_NULL_PMD: return RTE_STR(CRYPTODEV_NAME_NULL_PMD); break;
196 case RTE_CRYPTODEV_AESNI_GCM_PMD:
197 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
198 case RTE_CRYPTODEV_AESNI_MB_PMD:
199 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
200 case RTE_CRYPTODEV_QAT_SYM_PMD:
201 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
202 case RTE_CRYPTODEV_SNOW3G_PMD:
203 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
209 static const char *cipher_algo_name(enum rte_crypto_cipher_algorithm cipher_algo)
211 switch (cipher_algo) {
212 case RTE_CRYPTO_CIPHER_NULL: return "NULL";
213 case RTE_CRYPTO_CIPHER_3DES_CBC: return "3DES_CBC";
214 case RTE_CRYPTO_CIPHER_3DES_CTR: return "3DES_CTR";
215 case RTE_CRYPTO_CIPHER_3DES_ECB: return "3DES_ECB";
216 case RTE_CRYPTO_CIPHER_AES_CBC: return "AES_CBC";
217 case RTE_CRYPTO_CIPHER_AES_CCM: return "AES_CCM";
218 case RTE_CRYPTO_CIPHER_AES_CTR: return "AES_CTR";
219 case RTE_CRYPTO_CIPHER_AES_ECB: return "AES_ECB";
220 case RTE_CRYPTO_CIPHER_AES_F8: return "AES_F8";
221 case RTE_CRYPTO_CIPHER_AES_GCM: return "AES_GCM";
222 case RTE_CRYPTO_CIPHER_AES_XTS: return "AES_XTS";
223 case RTE_CRYPTO_CIPHER_ARC4: return "ARC4";
224 case RTE_CRYPTO_CIPHER_KASUMI_F8: return "KASUMI_F8";
225 case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: return "SNOW3G_UEA2";
226 case RTE_CRYPTO_CIPHER_ZUC_EEA3: return "ZUC_EEA3";
227 default: return "Another cipher algo";
231 static const char *auth_algo_name(enum rte_crypto_auth_algorithm auth_algo)
234 case RTE_CRYPTO_AUTH_NULL: return "NULL"; break;
235 case RTE_CRYPTO_AUTH_AES_CBC_MAC: return "AES_CBC_MAC"; break;
236 case RTE_CRYPTO_AUTH_AES_CCM: return "AES_CCM"; break;
237 case RTE_CRYPTO_AUTH_AES_CMAC: return "AES_CMAC,"; break;
238 case RTE_CRYPTO_AUTH_AES_GCM: return "AES_GCM"; break;
239 case RTE_CRYPTO_AUTH_AES_GMAC: return "AES_GMAC"; break;
240 case RTE_CRYPTO_AUTH_AES_XCBC_MAC: return "AES_XCBC_MAC"; break;
241 case RTE_CRYPTO_AUTH_KASUMI_F9: return "KASUMI_F9"; break;
242 case RTE_CRYPTO_AUTH_MD5: return "MD5"; break;
243 case RTE_CRYPTO_AUTH_MD5_HMAC: return "MD5_HMAC,"; break;
244 case RTE_CRYPTO_AUTH_SHA1: return "SHA1"; break;
245 case RTE_CRYPTO_AUTH_SHA1_HMAC: return "SHA1_HMAC"; break;
246 case RTE_CRYPTO_AUTH_SHA224: return "SHA224"; break;
247 case RTE_CRYPTO_AUTH_SHA224_HMAC: return "SHA224_HMAC"; break;
248 case RTE_CRYPTO_AUTH_SHA256: return "SHA256"; break;
249 case RTE_CRYPTO_AUTH_SHA256_HMAC: return "SHA256_HMAC"; break;
250 case RTE_CRYPTO_AUTH_SHA384: return "SHA384,"; break;
251 case RTE_CRYPTO_AUTH_SHA384_HMAC: return "SHA384_HMAC,"; break;
252 case RTE_CRYPTO_AUTH_SHA512: return "SHA512,"; break;
253 case RTE_CRYPTO_AUTH_SHA512_HMAC: return "SHA512_HMAC,"; break;
254 case RTE_CRYPTO_AUTH_SNOW3G_UIA2: return "SNOW3G_UIA2"; break;
255 case RTE_CRYPTO_AUTH_ZUC_EIA3: return "RTE_CRYPTO_AUTH_ZUC_EIA3"; break;
256 default: return "Another auth algo"; break;
260 static struct rte_mbuf *
261 setup_test_string(struct rte_mempool *mpool,
262 const uint8_t *data, size_t len, uint8_t blocksize)
264 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
265 size_t t_len = len - (blocksize ? (len % blocksize) : 0);
268 char *dst = rte_pktmbuf_append(m, t_len);
275 rte_memcpy(dst, (const void *)data, t_len);
280 static struct crypto_testsuite_params testsuite_params = { NULL };
281 static struct crypto_unittest_params unittest_params;
282 static enum rte_cryptodev_type gbl_cryptodev_perftest_devtype;
285 testsuite_setup(void)
287 struct crypto_testsuite_params *ts_params = &testsuite_params;
288 struct rte_cryptodev_info info;
289 unsigned i, nb_devs, valid_dev_id = 0;
293 ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
294 if (ts_params->mbuf_mp == NULL) {
295 /* Not already created so create */
296 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
297 "CRYPTO_PERF_MBUFPOOL",
298 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
300 if (ts_params->mbuf_mp == NULL) {
301 RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
307 ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
308 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
309 NUM_MBUFS, MBUF_CACHE_SIZE,
311 sizeof(struct rte_crypto_sym_xform),
313 if (ts_params->op_mpool == NULL) {
314 RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
318 /* Create 2 AESNI MB devices if required */
319 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_MB_PMD) {
320 #ifndef RTE_LIBRTE_PMD_AESNI_MB
321 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be"
322 " enabled in config file to run this testsuite.\n");
325 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD);
327 for (i = nb_devs; i < 2; i++) {
328 ret = rte_eal_vdev_init(
329 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
331 TEST_ASSERT(ret == 0,
332 "Failed to create instance %u of pmd : %s",
333 i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
338 /* Create 2 AESNI GCM devices if required */
339 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_AESNI_GCM_PMD) {
340 #ifndef RTE_LIBRTE_PMD_AESNI_GCM
341 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM must be"
342 " enabled in config file to run this testsuite.\n");
345 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD);
347 for (i = nb_devs; i < 2; i++) {
348 ret = rte_eal_vdev_init(
349 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
351 TEST_ASSERT(ret == 0,
352 "Failed to create instance %u of pmd : %s",
353 i, RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
358 /* Create 2 SNOW3G devices if required */
359 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_SNOW3G_PMD) {
360 #ifndef RTE_LIBRTE_PMD_SNOW3G
361 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_SNOW3G must be"
362 " enabled in config file to run this testsuite.\n");
365 nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD);
367 for (i = nb_devs; i < 2; i++) {
368 ret = rte_eal_vdev_init(
369 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
371 TEST_ASSERT(ret == 0,
372 "Failed to create instance %u of pmd : %s",
373 i, RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
378 /* Create 2 OPENSSL devices if required */
379 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_OPENSSL_PMD) {
380 #ifndef RTE_LIBRTE_PMD_OPENSSL
381 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_OPENSSL must be"
382 " enabled in config file to run this testsuite.\n");
385 nb_devs = rte_cryptodev_count_devtype(
386 RTE_CRYPTODEV_OPENSSL_PMD);
388 for (i = nb_devs; i < 2; i++) {
389 ret = rte_eal_vdev_init(
390 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
393 TEST_ASSERT(ret == 0, "Failed to create "
394 "instance %u of pmd : %s", i,
395 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
400 #ifndef RTE_LIBRTE_PMD_QAT
401 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
402 RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_QAT must be enabled "
403 "in config file to run this testsuite.\n");
408 nb_devs = rte_cryptodev_count();
410 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
414 /* Search for the first valid */
415 for (i = 0; i < nb_devs; i++) {
416 rte_cryptodev_info_get(i, &info);
417 if (info.dev_type == gbl_cryptodev_perftest_devtype) {
418 ts_params->dev_id = i;
428 * Using Crypto Device Id 0 by default.
429 * Set up all the qps on this device
432 rte_cryptodev_info_get(ts_params->dev_id, &info);
434 ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
435 ts_params->conf.socket_id = SOCKET_ID_ANY;
436 ts_params->conf.session_mp.nb_objs = info.sym.max_nb_sessions;
438 TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
440 "Failed to configure cryptodev %u",
443 ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
444 for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
446 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
447 ts_params->dev_id, qp_id,
449 rte_cryptodev_socket_id(ts_params->dev_id)),
450 "Failed to setup queue pair %u on cryptodev %u",
451 qp_id, ts_params->dev_id);
457 testsuite_teardown(void)
459 struct crypto_testsuite_params *ts_params =
462 if (ts_params->mbuf_mp != NULL)
463 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
464 rte_mempool_avail_count(ts_params->mbuf_mp));
465 if (ts_params->op_mpool != NULL)
466 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
467 rte_mempool_avail_count(ts_params->op_mpool));
473 struct crypto_testsuite_params *ts_params = &testsuite_params;
474 struct crypto_unittest_params *ut_params = &unittest_params;
476 /* Clear unit test parameters before running test */
477 memset(ut_params, 0, sizeof(*ut_params));
479 rte_cryptodev_stats_reset(ts_params->dev_id);
481 /* Start the device */
482 TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
483 "Failed to start cryptodev %u",
492 struct crypto_testsuite_params *ts_params = &testsuite_params;
493 struct crypto_unittest_params *ut_params = &unittest_params;
494 struct rte_cryptodev_stats stats;
498 /* free crypto session structure */
500 rte_cryptodev_sym_session_free(ts_params->dev_id,
503 /* free crypto operation structure */
505 rte_crypto_op_free(ut_params->op);
507 for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
508 if (ut_params->obuf[i])
509 rte_pktmbuf_free(ut_params->obuf[i]);
510 else if (ut_params->ibuf[i])
511 rte_pktmbuf_free(ut_params->ibuf[i]);
514 if (ts_params->mbuf_mp != NULL)
515 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
516 rte_mempool_avail_count(ts_params->mbuf_mp));
518 rte_cryptodev_stats_get(ts_params->dev_id, &stats);
520 /* Stop the device */
521 rte_cryptodev_stop(ts_params->dev_id);
524 const char plaintext_quote[] =
525 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
526 "Marseilles--The Arrival. On the 24th of February, 1815, the "
527 "look-out at Notre-Dame de la Garde signalled the three-master,"
528 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
529 "pilot put off immediately, and rounding the Chateau d'If, got "
530 "on board the vessel between Cape Morgion and Rion island. "
531 "Immediately, and according to custom, the ramparts of Fort "
532 "Saint-Jean were covered with spectators; it is always an event "
533 "at Marseilles for a ship to come into port, especially when "
534 "this ship, like the Pharaon, has been built, rigged, and laden"
535 " at the old Phocee docks, and belongs to an owner of the city."
536 " The ship drew on and had safely passed the strait, which some"
537 " volcanic shock has made between the Calasareigne and Jaros "
538 "islands; had doubled Pomegue, and approached the harbor under"
539 " topsails, jib, and spanker, but so slowly and sedately that"
540 " the idlers, with that instinct which is the forerunner of "
541 "evil, asked one another what misfortune could have happened "
542 "on board. However, those experienced in navigation saw plainly"
543 " that if any accident had occurred, it was not to the vessel "
544 "herself, for she bore down with all the evidence of being "
545 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
546 "already eased off, and standing by the side of the pilot, who"
547 " was steering the Pharaon towards the narrow entrance of the"
548 " inner port, was a young man, who, with activity and vigilant"
549 " eye, watched every motion of the ship, and repeated each "
550 "direction of the pilot. The vague disquietude which prevailed "
551 "among the spectators had so much affected one of the crowd "
552 "that he did not await the arrival of the vessel in harbor, but"
553 " jumping into a small skiff, desired to be pulled alongside "
554 "the Pharaon, which he reached as she rounded into La Reserve "
555 "basin. When the young man on board saw this person approach, "
556 "he left his station by the pilot, and, hat in hand, leaned "
557 "over the ship's bulwarks. He was a fine, tall, slim young "
558 "fellow of eighteen or twenty, with black eyes, and hair as "
559 "dark as a raven's wing; and his whole appearance bespoke that "
560 "calmness and resolution peculiar to men accustomed from their "
561 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
562 "cried the man in the skiff. \"What's the matter? and why have "
563 "you such an air of sadness aboard?\" \"A great misfortune, M. "
564 "Morrel,\" replied the young man,--\"a great misfortune, for me"
565 " especially! Off Civita Vecchia we lost our brave Captain "
566 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
567 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
568 " that head. But poor Captain Leclere--\" \"What happened to "
569 "him?\" asked the owner, with an air of considerable "
570 "resignation. \"What happened to the worthy captain?\" \"He "
571 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
572 "brain-fever in dreadful agony.\" Then turning to the crew, "
573 "he said, \"Bear a hand there, to take in sail!\" All hands "
574 "obeyed, and at once the eight or ten seamen who composed the "
575 "crew, sprang to their respective stations at the spanker "
576 "brails and outhaul, topsail sheets and halyards, the jib "
577 "downhaul, and the topsail clewlines and buntlines. The young "
578 "sailor gave a look to see that his orders were promptly and "
579 "accurately obeyed, and then turned again to the owner. \"And "
580 "how did this misfortune occur?\" inquired the latter, resuming"
581 " the interrupted conversation. \"Alas, sir, in the most "
582 "unexpected manner. After a long talk with the harbor-master, "
583 "Captain Leclere left Naples greatly disturbed in mind. In "
584 "twenty-four hours he was attacked by a fever, and died three "
585 "days afterwards. We performed the usual burial service, and he"
586 " is at his rest, sewn up in his hammock with a thirty-six "
587 "pound shot at his head and his heels, off El Giglio island. "
588 "We bring to his widow his sword and cross of honor. It was "
589 "worth while, truly,\" added the young man with a melancholy "
590 "smile, \"to make war against the English for ten years, and "
591 "to die in his bed at last, like everybody else.";
593 #define QUOTE_LEN_64B (64)
594 #define QUOTE_LEN_128B (128)
595 #define QUOTE_LEN_256B (256)
596 #define QUOTE_LEN_512B (512)
597 #define QUOTE_LEN_768B (768)
598 #define QUOTE_LEN_1024B (1024)
599 #define QUOTE_LEN_1280B (1280)
600 #define QUOTE_LEN_1536B (1536)
601 #define QUOTE_LEN_1792B (1792)
602 #define QUOTE_LEN_2048B (2048)
605 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
607 #define HMAC_KEY_LENGTH_SHA256 (DIGEST_BYTE_LENGTH_SHA256)
609 #define CIPHER_KEY_LENGTH_AES_CBC (16)
610 #define CIPHER_IV_LENGTH_AES_CBC (CIPHER_KEY_LENGTH_AES_CBC)
612 static uint8_t aes_cbc_128_key[] = {
613 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
614 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
616 static uint8_t aes_cbc_128_iv[] = {
617 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
618 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
620 static uint8_t hmac_sha256_key[] = {
621 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
622 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
623 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
624 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
627 /* Cipher text output */
629 static const uint8_t AES_CBC_ciphertext_64B[] = {
630 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
631 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
632 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
633 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
634 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
635 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
636 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
637 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
640 static const uint8_t AES_CBC_ciphertext_128B[] = {
641 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
642 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
643 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
644 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
645 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
646 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
647 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
648 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
649 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
650 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
651 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
652 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
653 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
654 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
655 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
656 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
659 static const uint8_t AES_CBC_ciphertext_256B[] = {
660 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
661 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
662 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
663 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
664 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
665 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
666 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
667 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
668 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
669 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
670 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
671 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
672 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
673 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
674 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
675 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
676 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
677 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
678 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
679 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
680 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
681 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
682 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
683 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
684 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
685 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
686 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
687 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
688 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
689 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
690 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
691 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
694 static const uint8_t AES_CBC_ciphertext_512B[] = {
695 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
696 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
697 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
698 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
699 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
700 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
701 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
702 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
703 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
704 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
705 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
706 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
707 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
708 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
709 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
710 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
711 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
712 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
713 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
714 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
715 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
716 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
717 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
718 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
719 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
720 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
721 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
722 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
723 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
724 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
725 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
726 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
727 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
728 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
729 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
730 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
731 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
732 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
733 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
734 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
735 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
736 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
737 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
738 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
739 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
740 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
741 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
742 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
743 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
744 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
745 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
746 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
747 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
748 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
749 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
750 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
751 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
752 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
753 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
754 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
755 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
756 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
757 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
758 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
761 static const uint8_t AES_CBC_ciphertext_768B[] = {
762 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
763 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
764 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
765 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
766 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
767 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
768 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
769 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
770 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
771 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
772 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
773 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
774 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
775 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
776 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
777 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
778 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
779 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
780 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
781 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
782 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
783 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
784 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
785 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
786 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
787 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
788 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
789 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
790 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
791 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
792 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
793 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
794 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
795 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
796 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
797 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
798 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
799 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
800 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
801 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
802 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
803 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
804 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
805 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
806 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
807 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
808 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
809 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
810 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
811 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
812 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
813 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
814 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
815 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
816 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
817 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
818 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
819 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
820 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
821 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
822 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
823 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
824 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
825 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
826 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
827 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
828 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
829 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
830 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
831 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
832 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
833 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
834 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
835 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
836 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
837 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
838 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
839 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
840 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
841 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
842 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
843 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
844 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
845 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
846 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
847 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
848 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
849 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
850 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
851 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
852 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
853 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
854 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
855 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
856 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
857 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
860 static const uint8_t AES_CBC_ciphertext_1024B[] = {
861 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
862 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
863 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
864 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
865 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
866 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
867 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
868 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
869 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
870 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
871 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
872 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
873 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
874 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
875 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
876 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
877 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
878 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
879 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
880 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
881 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
882 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
883 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
884 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
885 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
886 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
887 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
888 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
889 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
890 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
891 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
892 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
893 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
894 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
895 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
896 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
897 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
898 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
899 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
900 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
901 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
902 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
903 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
904 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
905 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
906 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
907 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
908 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
909 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
910 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
911 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
912 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
913 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
914 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
915 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
916 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
917 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
918 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
919 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
920 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
921 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
922 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
923 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
924 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
925 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
926 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
927 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
928 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
929 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
930 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
931 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
932 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
933 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
934 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
935 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
936 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
937 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
938 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
939 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
940 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
941 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
942 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
943 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
944 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
945 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
946 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
947 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
948 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
949 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
950 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
951 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
952 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
953 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
954 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
955 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
956 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
957 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
958 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
959 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
960 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
961 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
962 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
963 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
964 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
965 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
966 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
967 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
968 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
969 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
970 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
971 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
972 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
973 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
974 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
975 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
976 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
977 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
978 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
979 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
980 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
981 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
982 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
983 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
984 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
985 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
986 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
987 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
988 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
991 static const uint8_t AES_CBC_ciphertext_1280B[] = {
992 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
993 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
994 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
995 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
996 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
997 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
998 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
999 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
1000 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
1001 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
1002 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
1003 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
1004 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
1005 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
1006 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
1007 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
1008 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
1009 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
1010 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
1011 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
1012 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
1013 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
1014 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
1015 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
1016 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
1017 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
1018 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
1019 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
1020 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
1021 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
1022 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
1023 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
1024 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
1025 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
1026 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
1027 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
1028 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
1029 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1030 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1031 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1032 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1033 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1034 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1035 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1036 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1037 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1038 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1039 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1040 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1041 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1042 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1043 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1044 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1045 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1046 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1047 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1048 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1049 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1050 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1051 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1052 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1053 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1054 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1055 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1056 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1057 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1058 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1059 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1060 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1061 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1062 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1063 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1064 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1065 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1066 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1067 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1068 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1069 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1070 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1071 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1072 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1073 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1074 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1075 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1076 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1077 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1078 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1079 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1080 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1081 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1082 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1083 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1084 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1085 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1086 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1087 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1088 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1089 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1090 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1091 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1092 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1093 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1094 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1095 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1096 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1097 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1098 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1099 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1100 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1101 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1102 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1103 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1104 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1105 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1106 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1107 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1108 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1109 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1110 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1111 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1112 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1113 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1114 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1115 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1116 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1117 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1118 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1119 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1120 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1121 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1122 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1123 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1124 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1125 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1126 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1127 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1128 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1129 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1130 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1131 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1132 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1133 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1134 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1135 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1136 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1137 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1138 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1139 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1140 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1141 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1142 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1143 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1144 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1145 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1146 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1147 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1148 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1149 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1150 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1151 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1154 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1155 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1156 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1157 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1158 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1159 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1160 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1161 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1162 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1163 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1164 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1165 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1166 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1167 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1168 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1169 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1170 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1171 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1172 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1173 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1174 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1175 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1176 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1177 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1178 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1179 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1180 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1181 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1182 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1183 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1184 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1185 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1186 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1187 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1188 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1189 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1190 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1191 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1192 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1193 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1194 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1195 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1196 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1197 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1198 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1199 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1200 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1201 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1202 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1203 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1204 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1205 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1206 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1207 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1208 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1209 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1210 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1211 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1212 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1213 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1214 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1215 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1216 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1217 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1218 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1219 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1220 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1221 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1222 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1223 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1224 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1225 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1226 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1227 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1228 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1229 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1230 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1231 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1232 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1233 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1234 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1235 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1236 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1237 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1238 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1239 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1240 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1241 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1242 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1243 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1244 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1245 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1246 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1247 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1248 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1249 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1250 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1251 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1252 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1253 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1254 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1255 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1256 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1257 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1258 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1259 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1260 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1261 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1262 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1263 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1264 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1265 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1266 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1267 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1268 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1269 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1270 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1271 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1272 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1273 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1274 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1275 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1276 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1277 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1278 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1279 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1280 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1281 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1282 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1283 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1284 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1285 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1286 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1287 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1288 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1289 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1290 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1291 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1292 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1293 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1294 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1295 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1296 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1297 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1298 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1299 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1300 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1301 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1302 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1303 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1304 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1305 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1306 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1307 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1308 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1309 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1310 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1311 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1312 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1313 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1314 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1315 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1316 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1317 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1318 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1319 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1320 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1321 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1322 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1323 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1324 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1325 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1326 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1327 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1328 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1329 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1330 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1331 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1332 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1333 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1334 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1335 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1336 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1337 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1338 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1339 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1340 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1341 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1342 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1343 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1344 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1345 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1346 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1349 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1350 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1351 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1352 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1353 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1354 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1355 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1356 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1357 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1358 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1359 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1360 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1361 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1362 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1363 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1364 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1365 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1366 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1367 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1368 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1369 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1370 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1371 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1372 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1373 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1374 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1375 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1376 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1377 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1378 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1379 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1380 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1381 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1382 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1383 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1384 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1385 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1386 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1387 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1388 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1389 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1390 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1391 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1392 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1393 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1394 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1395 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1396 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1397 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1398 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1399 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1400 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1401 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1402 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1403 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1404 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1405 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1406 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1407 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1408 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1409 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1410 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1411 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1412 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1413 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1414 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1415 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1416 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1417 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1418 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1419 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1420 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1421 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1422 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1423 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1424 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1425 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1426 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1427 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1428 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1429 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1430 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1431 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1432 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1433 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1434 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1435 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1436 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1437 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1438 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1439 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1440 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1441 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1442 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1443 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1444 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1445 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1446 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1447 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1448 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1449 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1450 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1451 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1452 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1453 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1454 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1455 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1456 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1457 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1458 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1459 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1460 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1461 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1462 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1463 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1464 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1465 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1466 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1467 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1468 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1469 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1470 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1471 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1472 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1473 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1474 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1475 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1476 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1477 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1478 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1479 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1480 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1481 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1482 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1483 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1484 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1485 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1486 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1487 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1488 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1489 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1490 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1491 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1492 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1493 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1494 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1495 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1496 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1497 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1498 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1499 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1500 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1501 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1502 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1503 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1504 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1505 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1506 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1507 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1508 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1509 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1510 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1511 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1512 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1513 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1514 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1515 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1516 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1517 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1518 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1519 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1520 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1521 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1522 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1523 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1524 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1525 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1526 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1527 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1528 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1529 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1530 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1531 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1532 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1533 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1534 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1535 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1536 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1537 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1538 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1539 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1540 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1541 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1542 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1543 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1544 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1545 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1546 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1547 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1548 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1549 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1550 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1551 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1552 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1553 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1554 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1555 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1556 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1557 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1558 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1559 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1560 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1561 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1562 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1563 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1564 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1565 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1566 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1567 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1568 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1569 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1570 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1571 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1572 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1573 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1576 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1577 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1578 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1579 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1580 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1581 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1582 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1583 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1584 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1585 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1586 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1587 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1588 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1589 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1590 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1591 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1592 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1593 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1594 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1595 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1596 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1597 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1598 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1599 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1600 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1601 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1602 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1603 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1604 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1605 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1606 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1607 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1608 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1609 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1610 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1611 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1612 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1613 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1614 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1615 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1616 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1617 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1618 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1619 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1620 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1621 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1622 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1623 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1624 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1625 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1626 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1627 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1628 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1629 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1630 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1631 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1632 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1633 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1634 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1635 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1636 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1637 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1638 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1639 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1640 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1641 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1642 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1643 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1644 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1645 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1646 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1647 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1648 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1649 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1650 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1651 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1652 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1653 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1654 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1655 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1656 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1657 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1658 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1659 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1660 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1661 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1662 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1663 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1664 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1665 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1666 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1667 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1668 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1669 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1670 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1671 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1672 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1673 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1674 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1675 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1676 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1677 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1678 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1679 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1680 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1681 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1682 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1683 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1684 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1685 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1686 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1687 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1688 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1689 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1690 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1691 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1692 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1693 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1694 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1695 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1696 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1697 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1698 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1699 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1700 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1701 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1702 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1703 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1704 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1705 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1706 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1707 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1708 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1709 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1710 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1711 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1712 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1713 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1714 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1715 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1716 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1717 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1718 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1719 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1720 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1721 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1722 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1723 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1724 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1725 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1726 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1727 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1728 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1729 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1730 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1731 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1732 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1733 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1734 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1735 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1736 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1737 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1738 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1739 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1740 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1741 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1742 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1743 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1744 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1745 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1746 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1747 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1748 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1749 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1750 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1751 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1752 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1753 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1754 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1755 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1756 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1757 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1758 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1759 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1760 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1761 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1762 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1763 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1764 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1765 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1766 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1767 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1768 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1769 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1770 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1771 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1772 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1773 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1774 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1775 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1776 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1777 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1778 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1779 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1780 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1781 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1782 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1783 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1784 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1785 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1786 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1787 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1788 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1789 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1790 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1791 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1792 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1793 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1794 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1795 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1796 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1797 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1798 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1799 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1800 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1801 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1802 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1803 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1804 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1805 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1806 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1807 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1808 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1809 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1810 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1811 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1812 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1813 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1814 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1815 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1816 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1817 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1818 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1819 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1820 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1821 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1822 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1823 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1824 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1825 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1826 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1827 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1828 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1829 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1830 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1831 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1832 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1836 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1837 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1838 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1839 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1840 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1843 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1844 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1845 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1846 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1847 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1850 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1851 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1852 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1853 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1854 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1857 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1858 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1859 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1860 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1861 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1864 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1865 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1866 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1867 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1868 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1871 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1872 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1873 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1874 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1875 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1878 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1879 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1880 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1881 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1882 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1885 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1886 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1887 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1888 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1889 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1892 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1893 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1894 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1895 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1896 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1899 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1900 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1901 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1902 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1903 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1906 struct crypto_data_params {
1909 const char *plaintext;
1910 struct crypto_expected_output {
1911 const uint8_t *ciphertext;
1912 const uint8_t *digest;
1916 #define MAX_PACKET_SIZE_INDEX 10
1918 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1919 { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1920 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1921 { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1922 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1923 { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1924 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1925 { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1926 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1927 { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1928 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1929 { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1930 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1931 { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1932 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1933 { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1934 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1935 { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1936 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1937 { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1938 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1942 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1944 uint32_t num_to_submit = 4096;
1945 struct rte_crypto_op *c_ops[num_to_submit];
1946 struct rte_crypto_op *proc_ops[num_to_submit];
1947 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1948 uint32_t burst_sent, burst_received;
1949 uint32_t i, burst_size, num_sent, num_received;
1950 struct crypto_testsuite_params *ts_params = &testsuite_params;
1951 struct crypto_unittest_params *ut_params = &unittest_params;
1952 struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1954 if (rte_cryptodev_count() == 0) {
1955 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1959 /* Setup Cipher Parameters */
1960 ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1961 ut_params->cipher_xform.next = &ut_params->auth_xform;
1963 ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1964 ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1965 ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1966 ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1969 /* Setup HMAC Parameters */
1970 ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1971 ut_params->auth_xform.next = NULL;
1973 ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1974 ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1975 ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1976 ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1977 ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1979 /* Create Crypto session*/
1980 ut_params->sess = rte_cryptodev_sym_session_create(ts_params->dev_id,
1981 &ut_params->cipher_xform);
1983 TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
1985 /* Generate Crypto op data structure(s) */
1986 for (i = 0; i < num_to_submit ; i++) {
1987 struct rte_mbuf *m = setup_test_string(ts_params->mbuf_mp,
1988 data_params[0].expected.ciphertext,
1989 data_params[0].length, 0);
1990 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
1992 ut_params->digest = (uint8_t *)rte_pktmbuf_append(m,
1993 DIGEST_BYTE_LENGTH_SHA256);
1994 TEST_ASSERT_NOT_NULL(ut_params->digest,
1995 "no room to append digest");
1997 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1998 DIGEST_BYTE_LENGTH_SHA256);
2001 struct rte_crypto_op *op =
2002 rte_crypto_op_alloc(ts_params->op_mpool,
2003 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2005 rte_crypto_op_attach_sym_session(op, ut_params->sess);
2007 op->sym->auth.digest.data = ut_params->digest;
2008 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2009 data_params[0].length);
2010 op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256;
2012 op->sym->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2013 op->sym->auth.data.length = data_params[0].length;
2016 op->sym->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(m,
2017 CIPHER_IV_LENGTH_AES_CBC);
2018 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2019 op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
2021 rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv,
2022 CIPHER_IV_LENGTH_AES_CBC);
2024 op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC;
2025 op->sym->cipher.data.length = data_params[0].length;
2032 printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
2033 "algorithm with a constant request size of %u.",
2034 data_params[0].length);
2035 printf("\nThis test will keep retries at 0 and only measure IA cycle "
2036 "cost for each request.");
2037 printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2038 printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2039 "(assuming 0 retries)");
2040 for (i = 2; i <= 128 ; i *= 2) {
2047 while (num_sent < num_to_submit) {
2048 start_cycles = rte_rdtsc_precise();
2049 burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2050 0, &c_ops[num_sent],
2051 ((num_to_submit-num_sent) < burst_size) ?
2052 num_to_submit-num_sent : burst_size);
2053 if (burst_sent == 0)
2056 num_sent += burst_sent;
2057 end_cycles = rte_rdtsc_precise();
2058 total_cycles += (end_cycles - start_cycles);
2060 * Wait until requests have been sent.
2064 start_cycles = rte_rdtsc_precise();
2065 burst_received = rte_cryptodev_dequeue_burst(
2066 dev_num, 0, proc_ops, burst_size);
2067 if (burst_received == 0)
2070 num_received += burst_received;
2071 end_cycles = rte_rdtsc_precise();
2072 total_cycles += end_cycles - start_cycles;
2075 while (num_received != num_to_submit) {
2076 if (gbl_cryptodev_perftest_devtype ==
2077 RTE_CRYPTODEV_AESNI_MB_PMD)
2078 rte_cryptodev_enqueue_burst(dev_num, 0,
2081 burst_received = rte_cryptodev_dequeue_burst(
2082 dev_num, 0, proc_ops, burst_size);
2083 if (burst_received == 0)
2086 num_received += burst_received;
2089 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2090 num_sent, num_received, burst_size);
2091 printf("\t\t%"PRIu64, retries);
2092 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2096 for (i = 0; i < num_to_submit ; i++) {
2097 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2098 rte_crypto_op_free(c_ops[i]);
2100 return TEST_SUCCESS;
2104 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2106 uint32_t num_to_submit = pparams->total_operations;
2107 struct rte_crypto_op *c_ops[num_to_submit];
2108 struct rte_crypto_op *proc_ops[num_to_submit];
2109 uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2110 uint32_t burst_sent = 0, burst_received = 0;
2111 uint32_t i, burst_size, num_sent, num_ops_received;
2112 struct crypto_testsuite_params *ts_params = &testsuite_params;
2113 static struct rte_cryptodev_sym_session *sess;
2115 if (rte_cryptodev_count() == 0) {
2116 printf("\nNo crypto devices found. Is PMD build configured?\n");
2117 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2121 /* Create Crypto session*/
2122 sess = test_perf_create_snow3g_session(ts_params->dev_id,
2123 pparams->chain, pparams->cipher_algo,
2124 pparams->cipher_key_length, pparams->auth_algo);
2125 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2127 /* Generate Crypto op data structure(s)*/
2128 for (i = 0; i < num_to_submit ; i++) {
2129 struct rte_mbuf *m = test_perf_create_pktmbuf(
2132 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2134 struct rte_crypto_op *op =
2135 rte_crypto_op_alloc(ts_params->op_mpool,
2136 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2137 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2139 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size,
2140 get_auth_digest_length(pparams->auth_algo));
2141 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2146 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2147 "Packet Size %u bytes",
2148 pmd_name(gbl_cryptodev_perftest_devtype),
2149 ts_params->dev_id, 0,
2150 chain_mode_name(pparams->chain),
2151 cipher_algo_name(pparams->cipher_algo),
2152 auth_algo_name(pparams->auth_algo),
2154 printf("\nOps Tx\tOps Rx\tOps/burst ");
2155 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2157 for (i = 2; i <= 128 ; i *= 2) {
2159 num_ops_received = 0;
2164 while (num_sent < num_to_submit) {
2165 start_cycles = rte_rdtsc_precise();
2166 burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2167 0, &c_ops[num_sent],
2168 ((num_to_submit-num_sent) < burst_size) ?
2169 num_to_submit-num_sent : burst_size);
2170 end_cycles = rte_rdtsc_precise();
2171 if (burst_sent == 0)
2173 num_sent += burst_sent;
2174 total_cycles += (end_cycles - start_cycles);
2176 /* Wait until requests have been sent. */
2180 start_cycles = rte_rdtsc_precise();
2181 burst_received = rte_cryptodev_dequeue_burst(
2182 ts_params->dev_id, 0, proc_ops, burst_size);
2183 end_cycles = rte_rdtsc_precise();
2184 if (burst_received < burst_sent)
2186 num_ops_received += burst_received;
2188 total_cycles += end_cycles - start_cycles;
2191 while (num_ops_received != num_to_submit) {
2192 if (gbl_cryptodev_perftest_devtype ==
2193 RTE_CRYPTODEV_AESNI_MB_PMD)
2194 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2196 start_cycles = rte_rdtsc_precise();
2197 burst_received = rte_cryptodev_dequeue_burst(
2198 ts_params->dev_id, 0, proc_ops, burst_size);
2199 end_cycles = rte_rdtsc_precise();
2200 total_cycles += end_cycles - start_cycles;
2201 if (burst_received == 0)
2203 num_ops_received += burst_received;
2206 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2207 printf("\t\t%"PRIu64, retries);
2208 printf("\t%"PRIu64, failed_polls);
2209 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2210 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2211 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2215 for (i = 0; i < num_to_submit ; i++) {
2216 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2217 rte_crypto_op_free(c_ops[i]);
2219 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2221 return TEST_SUCCESS;
2225 test_perf_snow3G_vary_burst_size(void)
2227 unsigned total_operations = 4096;
2228 /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2229 uint16_t buf_lengths[] = {40};
2232 struct perf_test_params params_set[] = {
2234 .chain = CIPHER_ONLY,
2235 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2236 .cipher_key_length = 16,
2237 .auth_algo = RTE_CRYPTO_AUTH_NULL,
2241 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2242 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2243 .cipher_key_length = 16
2247 printf("\n\nStart %s.", __func__);
2248 printf("\nThis Test measures the average IA cycle cost using a "
2249 "constant request(packet) size. ");
2250 printf("Cycle cost is only valid when indicators show device is not busy,"
2251 " i.e. Retries and EmptyPolls = 0");
2253 for (i = 0; i < RTE_DIM(params_set); i++) {
2255 params_set[i].total_operations = total_operations;
2258 j < RTE_DIM(buf_lengths);
2261 params_set[i].buf_size = buf_lengths[j];
2263 test_perf_snow3G_optimise_cyclecount(¶ms_set[i]);
2272 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2274 uint32_t num_to_submit = pparams->total_operations;
2275 struct rte_crypto_op *c_ops[num_to_submit];
2276 struct rte_crypto_op *proc_ops[num_to_submit];
2277 uint64_t failed_polls, retries, start_cycles,
2278 end_cycles, total_cycles = 0;
2279 uint32_t burst_sent = 0, burst_received = 0;
2280 uint32_t i, burst_size, num_sent, num_ops_received;
2282 struct crypto_testsuite_params *ts_params = &testsuite_params;
2284 static struct rte_cryptodev_sym_session *sess;
2286 static struct rte_crypto_op *(*test_perf_set_crypto_op)
2287 (struct rte_crypto_op *, struct rte_mbuf *,
2288 struct rte_cryptodev_sym_session *,
2289 unsigned int, unsigned int);
2291 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
2293 if (rte_cryptodev_count() == 0) {
2294 printf("\nNo crypto devices found. Is PMD build configured?\n");
2298 /* Create Crypto session*/
2299 sess = test_perf_create_openssl_session(ts_params->dev_id,
2300 pparams->chain, pparams->cipher_algo,
2301 pparams->cipher_key_length, pparams->auth_algo);
2302 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2304 /* Generate Crypto op data structure(s)*/
2305 for (i = 0; i < num_to_submit ; i++) {
2306 struct rte_mbuf *m = test_perf_create_pktmbuf(
2309 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2311 struct rte_crypto_op *op =
2312 rte_crypto_op_alloc(ts_params->op_mpool,
2313 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2314 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2316 switch (pparams->cipher_algo) {
2317 case RTE_CRYPTO_CIPHER_3DES_CBC:
2318 case RTE_CRYPTO_CIPHER_3DES_CTR:
2319 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2321 case RTE_CRYPTO_CIPHER_AES_CBC:
2322 case RTE_CRYPTO_CIPHER_AES_CTR:
2323 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2325 case RTE_CRYPTO_CIPHER_AES_GCM:
2326 test_perf_set_crypto_op =
2327 test_perf_set_crypto_op_aes_gcm;
2333 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2335 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2340 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2341 "auth_algo:%s, Packet Size %u bytes",
2342 pmd_name(gbl_cryptodev_perftest_devtype),
2343 ts_params->dev_id, 0,
2344 chain_mode_name(pparams->chain),
2345 cipher_algo_name(pparams->cipher_algo),
2346 pparams->cipher_key_length,
2347 auth_algo_name(pparams->auth_algo),
2349 printf("\nOps Tx\tOps Rx\tOps/burst ");
2350 printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2353 for (i = 2; i <= 128 ; i *= 2) {
2355 num_ops_received = 0;
2360 while (num_sent < num_to_submit) {
2361 start_cycles = rte_rdtsc_precise();
2362 burst_sent = rte_cryptodev_enqueue_burst(
2364 0, &c_ops[num_sent],
2365 ((num_to_submit - num_sent) <
2367 num_to_submit - num_sent : burst_size);
2368 end_cycles = rte_rdtsc_precise();
2369 if (burst_sent == 0)
2371 num_sent += burst_sent;
2372 total_cycles += (end_cycles - start_cycles);
2374 /* Wait until requests have been sent. */
2377 start_cycles = rte_rdtsc_precise();
2378 burst_received = rte_cryptodev_dequeue_burst(
2379 ts_params->dev_id, 0, proc_ops,
2381 end_cycles = rte_rdtsc_precise();
2382 if (burst_received < burst_sent)
2384 num_ops_received += burst_received;
2386 total_cycles += end_cycles - start_cycles;
2389 while (num_ops_received != num_to_submit) {
2390 /* Sending 0 length burst to flush sw crypto device */
2391 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2394 start_cycles = rte_rdtsc_precise();
2395 burst_received = rte_cryptodev_dequeue_burst(
2396 ts_params->dev_id, 0, proc_ops,
2398 end_cycles = rte_rdtsc_precise();
2400 total_cycles += end_cycles - start_cycles;
2401 if (burst_received == 0)
2403 num_ops_received += burst_received;
2406 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2407 printf("\t\t%"PRIu64, retries);
2408 printf("\t%"PRIu64, failed_polls);
2409 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2410 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2412 printf("\t\t%"PRIu64,
2414 (num_ops_received * pparams->buf_size));
2418 for (i = 0; i < num_to_submit ; i++) {
2419 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2420 rte_crypto_op_free(c_ops[i]);
2422 rte_cryptodev_sym_session_free(ts_params->dev_id, sess);
2424 return TEST_SUCCESS;
2427 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2430 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2432 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2434 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2436 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2438 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2440 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2442 case RTE_CRYPTO_AUTH_AES_GCM:
2449 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2452 case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2454 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2455 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2456 case RTE_CRYPTO_AUTH_SHA224_HMAC:
2457 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2458 case RTE_CRYPTO_AUTH_SHA256_HMAC:
2459 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2460 case RTE_CRYPTO_AUTH_SHA384_HMAC:
2461 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2462 case RTE_CRYPTO_AUTH_SHA512_HMAC:
2463 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2464 case RTE_CRYPTO_AUTH_AES_GCM:
2465 return DIGEST_BYTE_LENGTH_AES_GCM;
2471 static uint8_t aes_key[] = {
2472 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2473 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2474 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2475 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2478 static uint8_t aes_iv[] = {
2479 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2480 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2483 static uint8_t triple_des_key[] = {
2484 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2485 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2486 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2489 static uint8_t triple_des_iv[] = {
2490 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2493 static uint8_t hmac_sha_key[] = {
2494 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2495 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2496 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2497 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2498 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2499 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2500 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2501 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2502 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2503 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2504 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2505 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2506 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2507 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2508 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2509 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2512 static uint8_t snow3g_cipher_key[] = {
2513 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2514 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2517 static uint8_t snow3g_iv[] = {
2518 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2519 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2522 static uint8_t snow3g_hash_key[] = {
2523 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2524 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2527 static struct rte_cryptodev_sym_session *
2528 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2529 enum rte_crypto_cipher_algorithm cipher_algo,
2530 unsigned cipher_key_len,
2531 enum rte_crypto_auth_algorithm auth_algo)
2533 struct rte_crypto_sym_xform cipher_xform = { 0 };
2534 struct rte_crypto_sym_xform auth_xform = { 0 };
2537 /* Setup Cipher Parameters */
2538 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2539 cipher_xform.cipher.algo = cipher_algo;
2540 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2542 cipher_xform.cipher.key.data = aes_key;
2543 cipher_xform.cipher.key.length = cipher_key_len;
2545 /* Setup HMAC Parameters */
2546 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2547 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2548 auth_xform.auth.algo = auth_algo;
2550 auth_xform.auth.key.data = hmac_sha_key;
2551 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2552 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2556 cipher_xform.next = &auth_xform;
2557 auth_xform.next = NULL;
2558 /* Create Crypto session*/
2559 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2561 auth_xform.next = &cipher_xform;
2562 cipher_xform.next = NULL;
2563 /* Create Crypto session*/
2564 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2570 #define SNOW3G_CIPHER_IV_LENGTH 16
2572 static struct rte_cryptodev_sym_session *
2573 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2574 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2575 enum rte_crypto_auth_algorithm auth_algo)
2577 struct rte_crypto_sym_xform cipher_xform = {0};
2578 struct rte_crypto_sym_xform auth_xform = {0};
2581 /* Setup Cipher Parameters */
2582 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2583 cipher_xform.cipher.algo = cipher_algo;
2584 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2586 cipher_xform.cipher.key.data = snow3g_cipher_key;
2587 cipher_xform.cipher.key.length = cipher_key_len;
2589 /* Setup HMAC Parameters */
2590 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2591 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2592 auth_xform.auth.algo = auth_algo;
2594 auth_xform.auth.add_auth_data_length = SNOW3G_CIPHER_IV_LENGTH;
2595 auth_xform.auth.key.data = snow3g_hash_key;
2596 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2597 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2601 cipher_xform.next = &auth_xform;
2602 auth_xform.next = NULL;
2603 /* Create Crypto session*/
2604 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2606 auth_xform.next = &cipher_xform;
2607 cipher_xform.next = NULL;
2608 /* Create Crypto session*/
2609 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2611 cipher_xform.next = NULL;
2612 /* Create Crypto session*/
2613 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2615 auth_xform.next = NULL;
2616 /* Create Crypto session */
2617 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2623 static struct rte_cryptodev_sym_session *
2624 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2625 enum rte_crypto_cipher_algorithm cipher_algo,
2626 unsigned int cipher_key_len,
2627 enum rte_crypto_auth_algorithm auth_algo)
2629 struct rte_crypto_sym_xform cipher_xform = { 0 };
2630 struct rte_crypto_sym_xform auth_xform = { 0 };
2632 /* Setup Cipher Parameters */
2633 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2634 cipher_xform.cipher.algo = cipher_algo;
2635 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2637 switch (cipher_algo) {
2638 case RTE_CRYPTO_CIPHER_3DES_CBC:
2639 case RTE_CRYPTO_CIPHER_3DES_CTR:
2640 cipher_xform.cipher.key.data = triple_des_key;
2642 case RTE_CRYPTO_CIPHER_AES_CBC:
2643 case RTE_CRYPTO_CIPHER_AES_CTR:
2644 case RTE_CRYPTO_CIPHER_AES_GCM:
2645 cipher_xform.cipher.key.data = aes_key;
2651 cipher_xform.cipher.key.length = cipher_key_len;
2653 /* Setup Auth Parameters */
2654 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2655 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2656 auth_xform.auth.algo = auth_algo;
2658 switch (auth_algo) {
2659 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2660 auth_xform.auth.key.data = hmac_sha_key;
2662 case RTE_CRYPTO_AUTH_AES_GCM:
2663 auth_xform.auth.key.data = NULL;
2669 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2670 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2674 cipher_xform.next = &auth_xform;
2675 auth_xform.next = NULL;
2676 /* Create Crypto session*/
2677 return rte_cryptodev_sym_session_create(dev_id, &cipher_xform);
2679 auth_xform.next = &cipher_xform;
2680 cipher_xform.next = NULL;
2681 /* Create Crypto session*/
2682 return rte_cryptodev_sym_session_create(dev_id, &auth_xform);
2688 #define AES_BLOCK_SIZE 16
2689 #define AES_CIPHER_IV_LENGTH 16
2691 #define TRIPLE_DES_BLOCK_SIZE 8
2692 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
2694 static struct rte_mbuf *
2695 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2697 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2699 if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2700 rte_pktmbuf_free(m);
2704 memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2709 static inline struct rte_crypto_op *
2710 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2711 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2712 unsigned digest_len)
2714 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2715 rte_crypto_op_free(op);
2719 /* Authentication Parameters */
2720 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m, uint8_t *,
2721 AES_CIPHER_IV_LENGTH + data_len);
2722 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
2723 AES_CIPHER_IV_LENGTH + data_len);
2724 op->sym->auth.digest.length = digest_len;
2725 op->sym->auth.aad.data = aes_iv;
2726 op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH;
2728 /* Cipher Parameters */
2729 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
2730 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2731 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2733 rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH);
2735 /* Data lengths/offsets Parameters */
2736 op->sym->auth.data.offset = AES_CIPHER_IV_LENGTH;
2737 op->sym->auth.data.length = data_len;
2739 op->sym->cipher.data.offset = AES_CIPHER_IV_LENGTH;
2740 op->sym->cipher.data.length = data_len;
2747 static inline struct rte_crypto_op *
2748 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
2749 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2750 unsigned int digest_len)
2752 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2753 rte_crypto_op_free(op);
2757 /* Authentication Parameters */
2758 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2759 (m->data_off + data_len);
2760 op->sym->auth.digest.phys_addr =
2761 rte_pktmbuf_mtophys_offset(m, data_len);
2762 op->sym->auth.digest.length = digest_len;
2763 op->sym->auth.aad.data = aes_iv;
2764 op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH;
2766 /* Cipher Parameters */
2767 op->sym->cipher.iv.data = aes_iv;
2768 op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH;
2770 /* Data lengths/offsets Parameters */
2771 op->sym->auth.data.offset = AES_BLOCK_SIZE;
2772 op->sym->auth.data.length = data_len - AES_BLOCK_SIZE;
2774 op->sym->cipher.data.offset = AES_BLOCK_SIZE;
2775 op->sym->cipher.data.length = data_len - AES_BLOCK_SIZE;
2782 static inline struct rte_crypto_op *
2783 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
2784 struct rte_cryptodev_sym_session *sess, unsigned data_len,
2785 unsigned digest_len)
2787 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2788 rte_crypto_op_free(op);
2792 /* Authentication Parameters */
2793 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2794 (m->data_off + data_len);
2795 op->sym->auth.digest.phys_addr =
2796 rte_pktmbuf_mtophys_offset(m, data_len);
2797 op->sym->auth.digest.length = digest_len;
2798 op->sym->auth.aad.data = snow3g_iv;
2799 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
2801 /* Cipher Parameters */
2802 op->sym->cipher.iv.data = snow3g_iv;
2803 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2805 /* Data lengths/offsets Parameters */
2806 op->sym->auth.data.offset = 0;
2807 op->sym->auth.data.length = data_len << 3;
2809 op->sym->cipher.data.offset = 0;
2810 op->sym->cipher.data.length = data_len << 3;
2817 static inline struct rte_crypto_op *
2818 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
2820 struct rte_cryptodev_sym_session *sess,
2823 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2824 rte_crypto_op_free(op);
2828 /* Cipher Parameters */
2829 op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *);
2830 op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2831 rte_memcpy(op->sym->cipher.iv.data, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
2832 op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m);
2834 op->sym->cipher.data.offset = SNOW3G_CIPHER_IV_LENGTH;
2835 op->sym->cipher.data.length = data_len << 3;
2843 static inline struct rte_crypto_op *
2844 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
2846 struct rte_cryptodev_sym_session *sess,
2848 unsigned digest_len)
2850 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2851 rte_crypto_op_free(op);
2855 /* Authentication Parameters */
2857 op->sym->auth.digest.data =
2858 (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
2860 op->sym->auth.digest.phys_addr =
2861 rte_pktmbuf_mtophys_offset(m, data_len +
2862 SNOW3G_CIPHER_IV_LENGTH);
2863 op->sym->auth.digest.length = digest_len;
2864 op->sym->auth.aad.data = rte_pktmbuf_mtod(m, uint8_t *);
2865 op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH;
2866 rte_memcpy(op->sym->auth.aad.data, snow3g_iv,
2867 SNOW3G_CIPHER_IV_LENGTH);
2868 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m);
2870 /* Data lengths/offsets Parameters */
2871 op->sym->auth.data.offset = SNOW3G_CIPHER_IV_LENGTH;
2872 op->sym->auth.data.length = data_len << 3;
2880 static inline struct rte_crypto_op *
2881 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
2882 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2883 unsigned int digest_len)
2885 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
2886 rte_crypto_op_free(op);
2890 /* Authentication Parameters */
2891 op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
2892 (m->data_off + data_len);
2893 op->sym->auth.digest.phys_addr =
2894 rte_pktmbuf_mtophys_offset(m, data_len);
2895 op->sym->auth.digest.length = digest_len;
2896 op->sym->auth.aad.data = triple_des_iv;
2897 op->sym->auth.aad.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2899 /* Cipher Parameters */
2900 op->sym->cipher.iv.data = triple_des_iv;
2901 op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2903 /* Data lengths/offsets Parameters */
2904 op->sym->auth.data.offset = 0;
2905 op->sym->auth.data.length = data_len;
2907 op->sym->cipher.data.offset = TRIPLE_DES_BLOCK_SIZE;
2908 op->sym->cipher.data.length = data_len - TRIPLE_DES_BLOCK_SIZE;
2915 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
2916 * same time, i.e. as they're not dereferenced there's no need to wait until
2917 * finished with to re-use */
2918 #define NUM_MBUF_SETS 8
2921 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
2922 struct perf_test_params *pparams)
2924 uint16_t i, k, l, m;
2926 uint16_t ops_unused = 0;
2928 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
2929 uint64_t processed = 0, failed_polls = 0, retries = 0;
2930 uint64_t tsc_start = 0, tsc_end = 0;
2932 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
2934 struct rte_crypto_op *ops[pparams->burst_size];
2935 struct rte_crypto_op *proc_ops[pparams->burst_size];
2937 struct rte_mbuf *mbufs[pparams->burst_size * 8];
2939 struct crypto_testsuite_params *ts_params = &testsuite_params;
2941 static struct rte_cryptodev_sym_session *sess;
2943 if (rte_cryptodev_count() == 0) {
2944 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
2948 /* Create Crypto session*/
2949 sess = test_perf_create_aes_sha_session(ts_params->dev_id,
2950 pparams->chain, pparams->cipher_algo,
2951 pparams->cipher_key_length, pparams->auth_algo);
2952 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2954 /* Generate a burst of crypto operations */
2955 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
2956 mbufs[i] = test_perf_create_pktmbuf(
2960 if (mbufs[i] == NULL) {
2961 printf("\nFailed to get mbuf - freeing the rest.\n");
2962 for (k = 0; k < i; k++)
2963 rte_pktmbuf_free(mbufs[k]);
2966 /* Make room for Digest and IV in mbuf */
2967 rte_pktmbuf_append(mbufs[i], digest_length);
2968 rte_pktmbuf_prepend(mbufs[i], AES_CIPHER_IV_LENGTH);
2972 tsc_start = rte_rdtsc_precise();
2974 while (total_enqueued < pparams->total_operations) {
2975 uint16_t burst_size =
2976 total_enqueued+pparams->burst_size <= pparams->total_operations ?
2977 pparams->burst_size : pparams->total_operations-total_enqueued;
2978 uint16_t ops_needed = burst_size-ops_unused;
2980 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
2981 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
2982 printf("\nFailed to alloc enough ops, finish dequeuing "
2983 "and free ops below.");
2985 for (i = 0; i < ops_needed; i++)
2986 ops[i] = test_perf_set_crypto_op_aes(ops[i],
2987 mbufs[i + (pparams->burst_size *
2988 (j % NUM_MBUF_SETS))],
2989 sess, pparams->buf_size, digest_length);
2992 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
2993 queue_id, ops, burst_size);
2995 if (burst_enqueued < burst_size)
2998 ops_unused = burst_size-burst_enqueued;
2999 total_enqueued += burst_enqueued;
3003 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3004 proc_ops, pparams->burst_size);
3005 if (burst_dequeued == 0)
3008 processed += burst_dequeued;
3010 for (l = 0; l < burst_dequeued; l++)
3011 rte_crypto_op_free(proc_ops[l]);
3016 /* Dequeue any operations still in the crypto device */
3017 while (processed < pparams->total_operations) {
3018 /* Sending 0 length burst to flush sw crypto device */
3019 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3022 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3023 proc_ops, pparams->burst_size);
3024 if (burst_dequeued == 0)
3027 processed += burst_dequeued;
3029 for (m = 0; m < burst_dequeued; m++)
3030 rte_crypto_op_free(proc_ops[m]);
3034 tsc_end = rte_rdtsc_precise();
3036 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3037 double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3039 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3040 throughput, retries, failed_polls);
3042 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3043 rte_pktmbuf_free(mbufs[i]);
3044 rte_cryptodev_sym_session_free(dev_id, sess);
3047 return TEST_SUCCESS;
3052 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3053 struct perf_test_params *pparams)
3055 uint16_t i, k, l, m;
3057 uint16_t ops_unused = 0;
3058 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3059 uint64_t processed = 0, failed_polls = 0, retries = 0;
3060 uint64_t tsc_start = 0, tsc_end = 0;
3062 uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3064 struct rte_crypto_op *ops[pparams->burst_size];
3065 struct rte_crypto_op *proc_ops[pparams->burst_size];
3067 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3069 struct crypto_testsuite_params *ts_params = &testsuite_params;
3071 static struct rte_cryptodev_sym_session *sess;
3073 if (rte_cryptodev_count() == 0) {
3074 printf("\nNo crypto devices found. Is PMD build configured?\n");
3075 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3079 /* Create Crypto session*/
3080 sess = test_perf_create_snow3g_session(ts_params->dev_id,
3081 pparams->chain, pparams->cipher_algo,
3082 pparams->cipher_key_length, pparams->auth_algo);
3083 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3085 /* Generate a burst of crypto operations */
3086 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3088 * Buffer size + iv/aad len is allocated, for perf tests they
3089 * are equal + digest len.
3091 mbufs[i] = test_perf_create_pktmbuf(
3093 pparams->buf_size + SNOW3G_CIPHER_IV_LENGTH +
3096 if (mbufs[i] == NULL) {
3097 printf("\nFailed to get mbuf - freeing the rest.\n");
3098 for (k = 0; k < i; k++)
3099 rte_pktmbuf_free(mbufs[k]);
3105 tsc_start = rte_rdtsc_precise();
3107 while (total_enqueued < pparams->total_operations) {
3108 uint16_t burst_size =
3109 (total_enqueued+pparams->burst_size)
3110 <= pparams->total_operations ?
3111 pparams->burst_size : pparams->total_operations-total_enqueued;
3112 uint16_t ops_needed = burst_size-ops_unused;
3113 /* Handle the last burst correctly */
3114 uint16_t op_offset = pparams->burst_size - burst_size;
3117 rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3118 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3119 ops+op_offset, ops_needed)) {
3120 printf("\nFailed to alloc enough ops.");
3121 /*Don't exit, dequeue, more ops should become available*/
3123 for (i = 0; i < ops_needed; i++) {
3124 if (pparams->chain == HASH_ONLY)
3126 test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3128 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3130 pparams->buf_size, digest_length);
3131 else if (pparams->chain == CIPHER_ONLY)
3133 test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3135 (pparams->burst_size * (j % NUM_MBUF_SETS))],
3144 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3145 ops+op_offset, burst_size);
3147 if (burst_enqueued < burst_size)
3150 ops_unused = burst_size-burst_enqueued;
3151 total_enqueued += burst_enqueued;
3155 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3156 proc_ops, pparams->burst_size);
3157 if (burst_dequeued == 0) {
3160 processed += burst_dequeued;
3161 for (l = 0; l < burst_dequeued; l++)
3162 rte_crypto_op_free(proc_ops[l]);
3167 /* Dequeue any operations still in the crypto device */
3168 while (processed < pparams->total_operations) {
3169 /* Sending 0 length burst to flush sw crypto device */
3170 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3173 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3174 proc_ops, pparams->burst_size);
3175 if (burst_dequeued == 0)
3178 processed += burst_dequeued;
3179 for (m = 0; m < burst_dequeued; m++)
3180 rte_crypto_op_free(proc_ops[m]);
3184 tsc_end = rte_rdtsc_precise();
3186 double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3187 double cycles_burst = (double) (tsc_end - tsc_start) /
3188 (double) processed * pparams->burst_size;
3189 double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3190 double cycles_B = cycles_buff / pparams->buf_size;
3191 double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3193 if (gbl_cryptodev_perftest_devtype == RTE_CRYPTODEV_QAT_SYM_PMD) {
3194 /* Cycle count misleading on HW devices for this test, so don't print */
3195 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3196 "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3197 pparams->buf_size, ops_s/1000000,
3198 throughput, retries, failed_polls);
3200 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3201 "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3202 pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3203 cycles_buff, cycles_B, retries, failed_polls);
3206 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3207 rte_pktmbuf_free(mbufs[i]);
3208 rte_cryptodev_sym_session_free(dev_id, sess);
3211 return TEST_SUCCESS;
3215 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3216 struct perf_test_params *pparams)
3218 uint16_t i, k, l, m;
3220 uint16_t ops_unused = 0;
3222 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3223 uint64_t processed = 0, failed_polls = 0, retries = 0;
3224 uint64_t tsc_start = 0, tsc_end = 0;
3226 unsigned int digest_length = get_auth_digest_length(pparams->auth_algo);
3228 struct rte_crypto_op *ops[pparams->burst_size];
3229 struct rte_crypto_op *proc_ops[pparams->burst_size];
3231 struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3233 struct crypto_testsuite_params *ts_params = &testsuite_params;
3235 static struct rte_cryptodev_sym_session *sess;
3237 static struct rte_crypto_op *(*test_perf_set_crypto_op)
3238 (struct rte_crypto_op *, struct rte_mbuf *,
3239 struct rte_cryptodev_sym_session *,
3240 unsigned int, unsigned int);
3242 switch (pparams->cipher_algo) {
3243 case RTE_CRYPTO_CIPHER_3DES_CBC:
3244 case RTE_CRYPTO_CIPHER_3DES_CTR:
3245 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3247 case RTE_CRYPTO_CIPHER_AES_CBC:
3248 case RTE_CRYPTO_CIPHER_AES_CTR:
3249 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3251 case RTE_CRYPTO_CIPHER_AES_GCM:
3252 test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm;
3258 if (rte_cryptodev_count() == 0) {
3259 printf("\nNo crypto devices found. Is PMD build configured?\n");
3263 /* Create Crypto session*/
3264 sess = test_perf_create_openssl_session(ts_params->dev_id,
3265 pparams->chain, pparams->cipher_algo,
3266 pparams->cipher_key_length, pparams->auth_algo);
3267 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3269 /* Generate a burst of crypto operations */
3270 for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3271 mbufs[i] = test_perf_create_pktmbuf(
3275 if (mbufs[i] == NULL) {
3276 printf("\nFailed to get mbuf - freeing the rest.\n");
3277 for (k = 0; k < i; k++)
3278 rte_pktmbuf_free(mbufs[k]);
3283 tsc_start = rte_rdtsc_precise();
3285 while (total_enqueued < pparams->total_operations) {
3286 uint16_t burst_size =
3287 total_enqueued + pparams->burst_size <=
3288 pparams->total_operations ? pparams->burst_size :
3289 pparams->total_operations - total_enqueued;
3290 uint16_t ops_needed = burst_size - ops_unused;
3292 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3293 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3294 printf("\nFailed to alloc enough ops, finish dequeuing "
3295 "and free ops below.");
3297 for (i = 0; i < ops_needed; i++)
3298 ops[i] = test_perf_set_crypto_op(ops[i],
3299 mbufs[i + (pparams->burst_size *
3300 (j % NUM_MBUF_SETS))],
3301 sess, pparams->buf_size, digest_length);
3304 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3305 queue_id, ops, burst_size);
3307 if (burst_enqueued < burst_size)
3310 ops_unused = burst_size - burst_enqueued;
3311 total_enqueued += burst_enqueued;
3315 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3316 proc_ops, pparams->burst_size);
3317 if (burst_dequeued == 0)
3320 processed += burst_dequeued;
3322 for (l = 0; l < burst_dequeued; l++)
3323 rte_crypto_op_free(proc_ops[l]);
3328 /* Dequeue any operations still in the crypto device */
3329 while (processed < pparams->total_operations) {
3330 /* Sending 0 length burst to flush sw crypto device */
3331 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3334 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3335 proc_ops, pparams->burst_size);
3336 if (burst_dequeued == 0)
3339 processed += burst_dequeued;
3341 for (m = 0; m < burst_dequeued; m++)
3342 rte_crypto_op_free(proc_ops[m]);
3346 tsc_end = rte_rdtsc_precise();
3348 double ops_s = ((double)processed / (tsc_end - tsc_start))
3350 double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3353 printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3354 ops_s / 1000000, throughput, retries, failed_polls);
3356 for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3357 rte_pktmbuf_free(mbufs[i]);
3358 rte_cryptodev_sym_session_free(dev_id, sess);
3361 return TEST_SUCCESS;
3366 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3367 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3368 perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3370 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3371 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3372 perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3374 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3375 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3376 perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3379 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3381 unsigned total_operations = 1000000;
3382 unsigned burst_size = 32;
3383 unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3386 struct perf_test_params params_set[] = {
3388 .chain = CIPHER_HASH,
3390 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3391 .cipher_key_length = 16,
3392 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3395 .chain = CIPHER_HASH,
3397 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3398 .cipher_key_length = 16,
3399 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3402 .chain = CIPHER_HASH,
3404 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3405 .cipher_key_length = 16,
3406 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3409 .chain = CIPHER_HASH,
3411 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3412 .cipher_key_length = 32,
3413 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3416 .chain = CIPHER_HASH,
3418 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3419 .cipher_key_length = 32,
3420 .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3423 .chain = CIPHER_HASH,
3425 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
3426 .cipher_key_length = 32,
3427 .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3431 for (i = 0; i < RTE_DIM(params_set); i++) {
3433 params_set[i].total_operations = total_operations;
3434 params_set[i].burst_size = burst_size;
3435 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3436 " burst_size: %d ops\n",
3437 chain_mode_name(params_set[i].chain),
3438 cipher_algo_name(params_set[i].cipher_algo),
3439 auth_algo_name(params_set[i].auth_algo),
3440 params_set[i].cipher_key_length,
3442 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3443 "Retries\tEmptyPolls\n");
3444 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3445 params_set[i].buf_size = buf_lengths[j];
3446 test_perf_aes_sha(testsuite_params.dev_id, 0,
3454 test_perf_snow3G_vary_pkt_size(void)
3456 unsigned total_operations = 1000000;
3459 uint16_t burst_sizes[] = { 64 };
3460 uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3462 struct perf_test_params params_set[] = {
3464 .chain = CIPHER_ONLY,
3465 .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3466 .cipher_key_length = 16,
3467 .auth_algo = RTE_CRYPTO_AUTH_NULL,
3471 .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3472 .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3473 .cipher_key_length = 16
3477 printf("\n\nStart %s.", __func__);
3478 printf("\nTest to measure max throughput at various pkt sizes.");
3479 printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3480 " so cycle cost not relevant (n/a displayed).");
3482 for (i = 0; i < RTE_DIM(params_set); i++) {
3484 params_set[i].total_operations = total_operations;
3485 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3486 printf("\nOn %s dev%u qp%u, %s, "
3487 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3488 pmd_name(gbl_cryptodev_perftest_devtype),
3489 testsuite_params.dev_id, 0,
3490 chain_mode_name(params_set[i].chain),
3491 cipher_algo_name(params_set[i].cipher_algo),
3492 auth_algo_name(params_set[i].auth_algo),
3495 params_set[i].burst_size = burst_sizes[k];
3496 printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3497 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3498 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3500 params_set[i].buf_size = buf_lengths[j];
3502 test_perf_snow3g(testsuite_params.dev_id, 0, ¶ms_set[i]);
3511 test_perf_openssl_vary_pkt_size(void)
3513 unsigned int total_operations = 10000;
3514 unsigned int burst_size = { 64 };
3515 unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3519 struct perf_test_params params_set[] = {
3521 .chain = CIPHER_HASH,
3523 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3524 .cipher_key_length = 16,
3525 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3528 .chain = CIPHER_HASH,
3530 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3531 .cipher_key_length = 24,
3532 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3535 .chain = CIPHER_HASH,
3537 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3538 .cipher_key_length = 16,
3539 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3542 .chain = CIPHER_HASH,
3544 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3545 .cipher_key_length = 32,
3546 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3549 .chain = CIPHER_HASH,
3551 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3552 .cipher_key_length = 16,
3553 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3556 .chain = CIPHER_HASH,
3558 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3559 .cipher_key_length = 24,
3560 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3563 .chain = CIPHER_HASH,
3565 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3566 .cipher_key_length = 16,
3567 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3571 for (i = 0; i < RTE_DIM(params_set); i++) {
3572 params_set[i].total_operations = total_operations;
3573 params_set[i].burst_size = burst_size;
3574 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3575 " burst_size: %d ops\n",
3576 chain_mode_name(params_set[i].chain),
3577 cipher_algo_name(params_set[i].cipher_algo),
3578 auth_algo_name(params_set[i].auth_algo),
3579 params_set[i].cipher_key_length,
3581 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
3583 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3584 params_set[i].buf_size = buf_lengths[j];
3585 test_perf_openssl(testsuite_params.dev_id, 0,
3594 test_perf_openssl_vary_burst_size(void)
3596 unsigned int total_operations = 4096;
3597 uint16_t buf_lengths[] = { 40 };
3600 struct perf_test_params params_set[] = {
3602 .chain = CIPHER_HASH,
3604 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3605 .cipher_key_length = 16,
3606 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3609 .chain = CIPHER_HASH,
3611 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC,
3612 .cipher_key_length = 24,
3613 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3616 .chain = CIPHER_HASH,
3618 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3619 .cipher_key_length = 16,
3620 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3623 .chain = CIPHER_HASH,
3625 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR,
3626 .cipher_key_length = 32,
3627 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3630 .chain = CIPHER_HASH,
3632 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3633 .cipher_key_length = 16,
3634 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3637 .chain = CIPHER_HASH,
3639 .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR,
3640 .cipher_key_length = 24,
3641 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3644 .chain = CIPHER_HASH,
3646 .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM,
3647 .cipher_key_length = 16,
3648 .auth_algo = RTE_CRYPTO_AUTH_AES_GCM
3652 printf("\n\nStart %s.", __func__);
3653 printf("\nThis Test measures the average IA cycle cost using a "
3654 "constant request(packet) size. ");
3655 printf("Cycle cost is only valid when indicators show device is not"
3656 " busy, i.e. Retries and EmptyPolls = 0");
3658 for (i = 0; i < RTE_DIM(params_set); i++) {
3660 params_set[i].total_operations = total_operations;
3662 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3663 params_set[i].buf_size = buf_lengths[j];
3664 test_perf_openssl_optimise_cyclecount(¶ms_set[i]);
3672 test_perf_aes_cbc_vary_burst_size(void)
3674 return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
3678 static struct rte_cryptodev_sym_session *
3679 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
3681 static struct rte_cryptodev_sym_session *sess;
3682 struct rte_crypto_sym_xform cipher_xform = { 0 };
3683 struct rte_crypto_sym_xform auth_xform = { 0 };
3685 uint8_t cipher_key[pparams->session_attrs->key_cipher_len];
3686 uint8_t auth_key[pparams->session_attrs->key_auth_len];
3688 memcpy(cipher_key, pparams->session_attrs->key_cipher_data,
3689 pparams->session_attrs->key_cipher_len);
3690 memcpy(auth_key, pparams->session_attrs->key_auth_data,
3691 pparams->session_attrs->key_auth_len);
3693 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
3694 cipher_xform.next = NULL;
3696 cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm;
3697 cipher_xform.cipher.op = pparams->session_attrs->cipher;
3698 cipher_xform.cipher.key.data = cipher_key;
3699 cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len;
3701 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
3702 auth_xform.next = NULL;
3704 auth_xform.auth.op = pparams->session_attrs->auth;
3705 auth_xform.auth.algo = pparams->session_attrs->auth_algorithm;
3707 auth_xform.auth.digest_length = pparams->session_attrs->digest_len;
3708 auth_xform.auth.key.length = pparams->session_attrs->key_auth_len;
3711 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3712 if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) {
3713 cipher_xform.next = &auth_xform;
3714 sess = rte_cryptodev_sym_session_create(dev_id,
3717 auth_xform.next = &cipher_xform;
3718 sess = rte_cryptodev_sym_session_create(dev_id,
3725 static inline struct rte_crypto_op *
3726 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
3727 struct rte_cryptodev_sym_session *sess,
3728 struct crypto_params *m_hlp,
3729 struct perf_test_params *params)
3731 if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3732 rte_crypto_op_free(op);
3736 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len,
3739 op->sym->auth.digest.data = m_hlp->digest;
3740 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(
3742 params->symmetric_op->aad_len +
3744 params->symmetric_op->p_len);
3746 op->sym->auth.digest.length = params->symmetric_op->t_len;
3748 op->sym->auth.aad.data = m_hlp->aad;
3749 op->sym->auth.aad.length = params->symmetric_op->aad_len;
3750 op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys_offset(
3754 rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data,
3755 params->symmetric_op->aad_len);
3757 op->sym->cipher.iv.data = m_hlp->iv;
3758 rte_memcpy(op->sym->cipher.iv.data, params->symmetric_op->iv_data,
3759 params->symmetric_op->iv_len);
3760 if (params->symmetric_op->iv_len == 12)
3761 op->sym->cipher.iv.data[15] = 1;
3763 op->sym->cipher.iv.length = params->symmetric_op->iv_len;
3765 op->sym->auth.data.offset =
3766 iv_pad_len + params->symmetric_op->aad_len;
3767 op->sym->auth.data.length = params->symmetric_op->p_len;
3769 op->sym->cipher.data.offset =
3770 iv_pad_len + params->symmetric_op->aad_len;
3771 op->sym->cipher.data.length = params->symmetric_op->p_len;
3778 static struct rte_mbuf *
3779 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
3780 struct perf_test_params *params,
3781 unsigned buf_sz, struct crypto_params *m_hlp)
3783 struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
3784 uint16_t iv_pad_len =
3785 ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, 16);
3786 uint16_t aad_len = params->symmetric_op->aad_len;
3787 uint16_t digest_size = params->symmetric_op->t_len;
3790 p = rte_pktmbuf_append(m, aad_len);
3792 rte_pktmbuf_free(m);
3795 m_hlp->aad = (uint8_t *)p;
3797 p = rte_pktmbuf_append(m, iv_pad_len);
3799 rte_pktmbuf_free(m);
3802 m_hlp->iv = (uint8_t *)p;
3804 p = rte_pktmbuf_append(m, buf_sz);
3806 rte_pktmbuf_free(m);
3809 rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
3811 p = rte_pktmbuf_append(m, digest_size);
3813 rte_pktmbuf_free(m);
3816 m_hlp->digest = (uint8_t *)p;
3822 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
3823 struct perf_test_params *pparams, uint32_t test_ops)
3826 struct crypto_testsuite_params *ts_params = &testsuite_params;
3827 struct rte_cryptodev_sym_session *sess;
3828 struct rte_crypto_op *ops[pparams->burst_size];
3829 struct rte_crypto_op *proc_ops[pparams->burst_size];
3830 uint32_t total_operations = pparams->total_operations;
3832 uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3833 uint64_t processed = 0, failed_polls = 0, retries = 0;
3834 uint64_t tsc_start = 0, tsc_end = 0;
3836 uint16_t i = 0, l = 0, m = 0;
3837 uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
3838 uint16_t ops_unused = 0;
3840 struct rte_mbuf *mbufs[burst];
3841 struct crypto_params m_hlp[burst];
3843 if (rte_cryptodev_count() == 0) {
3844 printf("\nNo crypto devices available. "
3845 "Is kernel driver loaded?\n");
3849 sess = test_perf_create_session(dev_id, pparams);
3850 TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3852 for (i = 0; i < burst; i++) {
3853 mbufs[i] = test_perf_create_pktmbuf_fill(
3855 pparams, pparams->symmetric_op->p_len,
3860 total_operations = test_ops;
3862 tsc_start = rte_rdtsc_precise();
3863 while (total_enqueued < total_operations) {
3864 uint16_t burst_size =
3865 total_enqueued+pparams->burst_size <= total_operations ?
3866 pparams->burst_size : total_operations-total_enqueued;
3867 uint16_t ops_needed = burst_size-ops_unused;
3869 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3870 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3871 printf("\nFailed to alloc enough ops, "
3872 "finish dequeuing");
3874 for (i = 0; i < ops_needed; i++)
3875 ops[i] = perf_gcm_set_crypto_op(ops[i],
3876 mbufs[i + (pparams->burst_size *
3877 (j % NUM_MBUF_SETS))],
3878 sess, &m_hlp[i + (pparams->burst_size *
3879 (j % NUM_MBUF_SETS))], pparams);
3882 burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3883 queue_id, ops, burst_size);
3885 if (burst_enqueued < burst_size)
3888 ops_unused = burst_size-burst_enqueued;
3889 total_enqueued += burst_enqueued;
3893 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3894 proc_ops, pparams->burst_size);
3895 if (burst_dequeued == 0)
3898 processed += burst_dequeued;
3900 for (l = 0; l < burst_dequeued; l++)
3901 rte_crypto_op_free(proc_ops[l]);
3907 /* Dequeue any operations still in the crypto device */
3908 while (processed < total_operations) {
3909 /* Sending 0 length burst to flush sw crypto device */
3910 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3913 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3914 proc_ops, pparams->burst_size);
3915 if (burst_dequeued == 0)
3918 processed += burst_dequeued;
3920 for (m = 0; m < burst_dequeued; m++) {
3922 uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP
3923 (pparams->symmetric_op->iv_len, 16);
3924 uint8_t *pkt = rte_pktmbuf_mtod(
3925 proc_ops[m]->sym->m_src,
3928 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3929 pparams->symmetric_op->c_data,
3931 pparams->symmetric_op->aad_len,
3932 pparams->symmetric_op->c_len,
3933 "GCM Ciphertext data not as expected");
3935 TEST_ASSERT_BUFFERS_ARE_EQUAL(
3936 pparams->symmetric_op->t_data,
3938 pparams->symmetric_op->aad_len +
3939 pparams->symmetric_op->c_len,
3940 pparams->symmetric_op->t_len,
3941 "GCM MAC data not as expected");
3944 rte_crypto_op_free(proc_ops[m]);
3949 tsc_end = rte_rdtsc_precise();
3951 double ops_s = ((double)processed / (tsc_end - tsc_start))
3953 double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
3957 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
3958 pparams->symmetric_op->p_len,
3959 ops_s/1000000, throughput, retries, failed_polls);
3962 for (i = 0; i < burst; i++)
3963 rte_pktmbuf_free(mbufs[i]);
3964 rte_cryptodev_sym_session_free(dev_id, sess);
3970 test_perf_AES_GCM(int continual_buf_len, int continual_size)
3972 uint16_t i, j, k, loops = 1;
3974 uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
3976 static const struct cryptodev_perf_test_data *gcm_tests[] = {
3977 &AES_GCM_128_12IV_0AAD
3980 if (continual_buf_len)
3981 loops = continual_size;
3983 int TEST_CASES_GCM = RTE_DIM(gcm_tests);
3985 const unsigned burst_size = 32;
3987 struct symmetric_op ops_set[TEST_CASES_GCM];
3988 struct perf_test_params params_set[TEST_CASES_GCM];
3989 struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
3990 static const struct cryptodev_perf_test_data *gcm_test;
3992 for (i = 0; i < TEST_CASES_GCM; ++i) {
3994 gcm_test = gcm_tests[i];
3996 session_attrs[i].cipher =
3997 RTE_CRYPTO_CIPHER_OP_ENCRYPT;
3998 session_attrs[i].cipher_algorithm =
3999 RTE_CRYPTO_CIPHER_AES_GCM;
4000 session_attrs[i].key_cipher_data =
4002 session_attrs[i].key_cipher_len =
4004 session_attrs[i].auth_algorithm =
4005 RTE_CRYPTO_AUTH_AES_GCM;
4006 session_attrs[i].auth =
4007 RTE_CRYPTO_AUTH_OP_GENERATE;
4008 session_attrs[i].key_auth_data = NULL;
4009 session_attrs[i].key_auth_len = 0;
4010 session_attrs[i].digest_len =
4011 gcm_test->auth_tag.len;
4013 ops_set[i].aad_data = gcm_test->aad.data;
4014 ops_set[i].aad_len = gcm_test->aad.len;
4015 ops_set[i].iv_data = gcm_test->iv.data;
4016 ops_set[i].iv_len = gcm_test->iv.len;
4017 ops_set[i].p_data = gcm_test->plaintext.data;
4018 ops_set[i].p_len = buf_lengths[i];
4019 ops_set[i].c_data = gcm_test->ciphertext.data;
4020 ops_set[i].c_len = buf_lengths[i];
4021 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4022 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4024 params_set[i].chain = CIPHER_HASH;
4025 params_set[i].session_attrs = &session_attrs[i];
4026 params_set[i].symmetric_op = &ops_set[i];
4027 if (continual_buf_len)
4028 params_set[i].total_operations = 0xFFFFFF;
4030 params_set[i].total_operations = 1000000;
4032 params_set[i].burst_size = burst_size;
4036 if (continual_buf_len)
4037 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4038 " burst size: %u", "AES_GCM", "AES_GCM",
4039 gcm_test->key.len << 3, burst_size);
4041 for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4043 if (!continual_buf_len) {
4044 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4045 " burst size: %u", "AES_GCM", "AES_GCM",
4046 gcm_test->key.len << 3, burst_size);
4047 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4048 " Retries\tEmptyPolls");
4051 uint16_t len = RTE_DIM(buf_lengths);
4054 if (continual_buf_len) {
4055 for (k = 0; k < RTE_DIM(buf_lengths); k++)
4056 if (buf_lengths[k] == continual_buf_len) {
4062 for (j = p; j < len; ++j) {
4064 params_set[i].symmetric_op->c_len = buf_lengths[j];
4065 params_set[i].symmetric_op->p_len = buf_lengths[j];
4067 ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4068 ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4070 /* Run is twice, one for encryption/hash checks,
4073 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4077 for (k = 0; k < loops; k++) {
4078 if (continual_buf_len)
4079 printf("\n\nBuffer Size(B)\tOPS(M)\t"
4080 "Throughput(Gbps)\t"
4081 "Retries\tEmptyPolls");
4082 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4085 if (continual_buf_len)
4086 printf("\n\nCompleted loop %i of %i ...",
4096 static int test_cryptodev_perf_AES_GCM(void)
4098 return test_perf_AES_GCM(0, 0);
4101 * This function calls AES GCM performance tests providing
4102 * size of packet as an argument. If size of packet is not
4103 * in the buf_lengths array, all sizes will be used
4105 static int test_continual_perf_AES_GCM(void)
4107 return test_perf_AES_GCM(1024, 10);
4111 test_perf_continual_performance_test(void)
4113 unsigned int total_operations = 0xFFFFFF;
4114 unsigned int total_loops = 10;
4115 unsigned int burst_size = 32;
4118 struct perf_test_params params_set = {
4119 .total_operations = total_operations,
4120 .burst_size = burst_size,
4123 .chain = CIPHER_HASH,
4125 .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC,
4126 .cipher_key_length = 16,
4127 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4130 for (i = 1; i <= total_loops; ++i) {
4131 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4132 " burst_size: %d ops\n",
4133 chain_mode_name(params_set.chain),
4134 cipher_algo_name(params_set.cipher_algo),
4135 auth_algo_name(params_set.auth_algo),
4136 params_set.cipher_key_length,
4138 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4139 "Retries\tEmptyPolls\n");
4140 test_perf_aes_sha(testsuite_params.dev_id, 0,
4142 printf("\nCompleted loop %i of %i ...", i, total_loops);
4147 static struct unit_test_suite cryptodev_qat_continual_testsuite = {
4148 .suite_name = "Crypto Device Continual Performance Test",
4149 .setup = testsuite_setup,
4150 .teardown = testsuite_teardown,
4151 .unit_test_cases = {
4152 TEST_CASE_ST(ut_setup, ut_teardown,
4153 test_perf_continual_performance_test),
4154 TEST_CASE_ST(ut_setup, ut_teardown,
4155 test_continual_perf_AES_GCM),
4156 TEST_CASES_END() /**< NULL terminate unit test array */
4160 static struct unit_test_suite cryptodev_testsuite = {
4161 .suite_name = "Crypto Device Unit Test Suite",
4162 .setup = testsuite_setup,
4163 .teardown = testsuite_teardown,
4164 .unit_test_cases = {
4165 TEST_CASE_ST(ut_setup, ut_teardown,
4166 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4167 TEST_CASE_ST(ut_setup, ut_teardown,
4168 test_cryptodev_perf_AES_GCM),
4169 TEST_CASE_ST(ut_setup, ut_teardown,
4170 test_perf_aes_cbc_vary_burst_size),
4171 TEST_CASES_END() /**< NULL terminate unit test array */
4175 static struct unit_test_suite cryptodev_gcm_testsuite = {
4176 .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4177 .setup = testsuite_setup,
4178 .teardown = testsuite_teardown,
4179 .unit_test_cases = {
4180 TEST_CASE_ST(ut_setup, ut_teardown,
4181 test_cryptodev_perf_AES_GCM),
4182 TEST_CASES_END() /**< NULL terminate unit test array */
4186 static struct unit_test_suite cryptodev_aes_testsuite = {
4187 .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4188 .setup = testsuite_setup,
4189 .teardown = testsuite_teardown,
4190 .unit_test_cases = {
4191 TEST_CASE_ST(ut_setup, ut_teardown,
4192 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4193 TEST_CASES_END() /**< NULL terminate unit test array */
4197 static struct unit_test_suite cryptodev_snow3g_testsuite = {
4198 .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4199 .setup = testsuite_setup,
4200 .teardown = testsuite_teardown,
4201 .unit_test_cases = {
4202 TEST_CASE_ST(ut_setup, ut_teardown,
4203 test_perf_snow3G_vary_pkt_size),
4204 TEST_CASE_ST(ut_setup, ut_teardown,
4205 test_perf_snow3G_vary_burst_size),
4206 TEST_CASES_END() /**< NULL terminate unit test array */
4210 static struct unit_test_suite cryptodev_openssl_testsuite = {
4211 .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4212 .setup = testsuite_setup,
4213 .teardown = testsuite_teardown,
4214 .unit_test_cases = {
4215 TEST_CASE_ST(ut_setup, ut_teardown,
4216 test_perf_openssl_vary_pkt_size),
4217 TEST_CASE_ST(ut_setup, ut_teardown,
4218 test_perf_openssl_vary_burst_size),
4219 TEST_CASES_END() /**< NULL terminate unit test array */
4224 perftest_aesni_gcm_cryptodev(void)
4226 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_GCM_PMD;
4228 return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4232 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4234 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_AESNI_MB_PMD;
4236 return unit_test_suite_runner(&cryptodev_aes_testsuite);
4240 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4242 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4244 return unit_test_suite_runner(&cryptodev_testsuite);
4248 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4250 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_SNOW3G_PMD;
4252 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4256 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4258 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4260 return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4264 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4266 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_OPENSSL_PMD;
4268 return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4272 perftest_qat_continual_cryptodev(void)
4274 gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_QAT_SYM_PMD;
4276 return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4279 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4280 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4281 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4282 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4283 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4284 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4285 perftest_openssl_cryptodev);
4286 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4287 perftest_qat_continual_cryptodev);