crypto/armv8: rename map file to standard name
[dpdk.git] / test / test / test_cryptodev_perf.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2015-2017 Intel Corporation. All rights reserved.
5  *
6  *   Redistribution and use in source and binary forms, with or without
7  *   modification, are permitted provided that the following conditions
8  *   are met:
9  *
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
15  *         distribution.
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.
19  *
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.
31  */
32
33 #include <rte_common.h>
34 #include <rte_mbuf.h>
35 #include <rte_malloc.h>
36 #include <rte_memcpy.h>
37
38 #include <rte_crypto.h>
39 #include <rte_cryptodev.h>
40 #include <rte_cycles.h>
41
42 #include "test.h"
43 #include "test_cryptodev.h"
44 #include "test_cryptodev_gcm_test_vectors.h"
45
46 #define AES_CIPHER_IV_LENGTH 16
47 #define TRIPLE_DES_CIPHER_IV_LENGTH 8
48 #define AES_GCM_AAD_LENGTH 16
49
50 #define PERF_NUM_OPS_INFLIGHT           (128)
51 #define DEFAULT_NUM_REQS_TO_SUBMIT      (10000000)
52
53 struct crypto_testsuite_params {
54         struct rte_mempool *mbuf_mp;
55         struct rte_mempool *op_mpool;
56         struct rte_mempool *sess_mp;
57
58         uint16_t nb_queue_pairs;
59
60         struct rte_cryptodev_config conf;
61         struct rte_cryptodev_qp_conf qp_conf;
62         uint8_t dev_id;
63 };
64
65 enum chain_mode {
66         CIPHER_HASH,
67         HASH_CIPHER,
68         CIPHER_ONLY,
69         HASH_ONLY,
70         AEAD
71 };
72
73
74 struct symmetric_op {
75         const uint8_t *aad_data;
76
77         const uint8_t *p_data;
78         uint32_t p_len;
79
80         const uint8_t *c_data;
81         uint32_t c_len;
82
83         const uint8_t *t_data;
84         uint32_t t_len;
85
86 };
87
88 struct symmetric_session_attrs {
89         enum rte_crypto_cipher_operation cipher;
90         enum rte_crypto_auth_operation auth;
91         enum rte_crypto_aead_operation aead;
92
93         enum rte_crypto_cipher_algorithm cipher_algorithm;
94         const uint8_t *key_cipher_data;
95         uint32_t key_cipher_len;
96
97         enum rte_crypto_auth_algorithm auth_algorithm;
98         const uint8_t *key_auth_data;
99         uint32_t key_auth_len;
100
101         enum rte_crypto_aead_algorithm aead_algorithm;
102         const uint8_t *key_aead_data;
103         uint32_t key_aead_len;
104
105         const uint8_t *iv_data;
106         uint16_t iv_len;
107         uint16_t aad_len;
108         uint32_t digest_len;
109 };
110
111 static struct rte_cryptodev_sym_session *test_crypto_session;
112
113 #define ALIGN_POW2_ROUNDUP(num, align) \
114         (((num) + (align) - 1) & ~((align) - 1))
115
116 /*
117  * This struct is needed to avoid unnecessary allocation or checking
118  * of allocation of crypto params with current alloc on the fly
119  * implementation.
120  */
121
122 struct crypto_params {
123         uint8_t *aad;
124         uint8_t *digest;
125 };
126
127 struct perf_test_params {
128
129         unsigned total_operations;
130         unsigned burst_size;
131         unsigned buf_size;
132
133         enum chain_mode chain;
134
135         enum rte_crypto_cipher_algorithm cipher_algo;
136         unsigned int key_length;
137         enum rte_crypto_auth_algorithm auth_algo;
138         enum rte_crypto_aead_algorithm aead_algo;
139
140         struct symmetric_session_attrs *session_attrs;
141
142         struct symmetric_op *symmetric_op;
143 };
144
145 #define MAX_NUM_OF_OPS_PER_UT   (128)
146
147 struct crypto_unittest_params {
148         struct rte_crypto_sym_xform cipher_xform;
149         struct rte_crypto_sym_xform auth_xform;
150
151         struct rte_cryptodev_sym_session *sess;
152
153         struct rte_crypto_op *op;
154
155         struct rte_mbuf *obuf[MAX_NUM_OF_OPS_PER_UT];
156         struct rte_mbuf *ibuf[MAX_NUM_OF_OPS_PER_UT];
157
158         uint8_t *digest;
159 };
160
161 static int
162 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
163                 enum rte_crypto_cipher_algorithm cipher_algo,
164                 unsigned int cipher_key_len,
165                 enum rte_crypto_auth_algorithm auth_algo);
166 static int
167 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
168                 enum rte_crypto_cipher_algorithm cipher_algo,
169                 unsigned int cipher_key_len,
170                 enum rte_crypto_auth_algorithm auth_algo,
171                 enum rte_crypto_aead_algorithm aead_algo);
172 static int
173 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
174                 enum rte_crypto_cipher_algorithm cipher_algo,
175                 unsigned int cipher_key_len,
176                 enum rte_crypto_auth_algorithm auth_algo);
177
178 static struct rte_mbuf *
179 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz);
180 static inline struct rte_crypto_op *
181 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
182                 struct rte_cryptodev_sym_session *sess, unsigned int data_len);
183 static inline struct rte_crypto_op *
184 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
185                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
186                 enum chain_mode chain);
187 static inline struct rte_crypto_op *
188 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
189                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
190                 enum chain_mode chain __rte_unused);
191 static inline struct rte_crypto_op *
192 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
193                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
194                 enum chain_mode chain __rte_unused);
195 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo);
196
197
198 static const char *chain_mode_name(enum chain_mode mode)
199 {
200         switch (mode) {
201         case CIPHER_HASH: return "cipher_hash"; break;
202         case HASH_CIPHER: return "hash_cipher"; break;
203         case CIPHER_ONLY: return "cipher_only"; break;
204         case HASH_ONLY: return "hash_only"; break;
205         case AEAD: return "aead"; break;
206         default: return ""; break;
207         }
208 }
209
210 static const char *pmd_name(uint8_t driver_id)
211 {
212         uint8_t null_pmd = rte_cryptodev_driver_id_get(
213                         RTE_STR(CRYPTODEV_NAME_NULL_PMD));
214         uint8_t dpaa2_pmd = rte_cryptodev_driver_id_get(
215                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
216         uint8_t snow3g_pmd = rte_cryptodev_driver_id_get(
217                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
218         uint8_t aesni_gcm_pmd = rte_cryptodev_driver_id_get(
219                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
220         uint8_t aesni_mb_pmd = rte_cryptodev_driver_id_get(
221                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
222         uint8_t qat_pmd = rte_cryptodev_driver_id_get(
223                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
224
225         if (driver_id == null_pmd)
226                 return RTE_STR(CRYPTODEV_NAME_NULL_PMD);
227         else if (driver_id == aesni_gcm_pmd)
228                 return RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD);
229         else if (driver_id == aesni_mb_pmd)
230                 return RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD);
231         else if (driver_id == qat_pmd)
232                 return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD);
233         else if (driver_id == snow3g_pmd)
234                 return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD);
235         else if (driver_id == dpaa2_pmd)
236                 return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD);
237         else
238                 return "";
239 }
240
241 static struct rte_mbuf *
242 setup_test_string(struct rte_mempool *mpool,
243                 const uint8_t *data, size_t len, uint8_t blocksize)
244 {
245         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
246         size_t t_len = len - (blocksize ? (len % blocksize) : 0);
247
248         if (m) {
249                 char *dst = rte_pktmbuf_append(m, t_len);
250
251                 if (!dst) {
252                         rte_pktmbuf_free(m);
253                         return NULL;
254                 }
255
256                 rte_memcpy(dst, (const void *)data, t_len);
257         }
258         return m;
259 }
260
261 static struct crypto_testsuite_params testsuite_params = { NULL };
262 static struct crypto_unittest_params unittest_params;
263 static int gbl_driver_id;
264
265 static int
266 testsuite_setup(void)
267 {
268         struct crypto_testsuite_params *ts_params = &testsuite_params;
269         struct rte_cryptodev_info info;
270         unsigned i, nb_devs, valid_dev_id = 0;
271         int ret;
272         uint16_t qp_id;
273
274         ts_params->mbuf_mp = rte_mempool_lookup("CRYPTO_PERF_MBUFPOOL");
275         if (ts_params->mbuf_mp == NULL) {
276                 /* Not already created so create */
277                 ts_params->mbuf_mp = rte_pktmbuf_pool_create(
278                                 "CRYPTO_PERF_MBUFPOOL",
279                                 NUM_MBUFS, MBUF_CACHE_SIZE, 0, MBUF_SIZE,
280                                 rte_socket_id());
281                 if (ts_params->mbuf_mp == NULL) {
282                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_PERF_MBUFPOOL\n");
283                         return TEST_FAILED;
284                 }
285         }
286
287
288         ts_params->op_mpool = rte_crypto_op_pool_create("CRYPTO_OP_POOL",
289                         RTE_CRYPTO_OP_TYPE_SYMMETRIC,
290                         NUM_MBUFS, MBUF_CACHE_SIZE,
291                         DEFAULT_NUM_XFORMS *
292                         sizeof(struct rte_crypto_sym_xform) +
293                         MAXIMUM_IV_LENGTH,
294                         rte_socket_id());
295                 if (ts_params->op_mpool == NULL) {
296                         RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n");
297                         return TEST_FAILED;
298                 }
299
300         /* Create an AESNI MB device if required */
301         if (gbl_driver_id == rte_cryptodev_driver_id_get(
302                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
303                 nb_devs = rte_cryptodev_device_count_by_driver(
304                                 rte_cryptodev_driver_id_get(
305                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
306                 if (nb_devs < 1) {
307                         ret = rte_vdev_init(
308                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
309
310                         TEST_ASSERT(ret == 0,
311                                 "Failed to create instance of pmd : %s",
312                                 RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
313                 }
314         }
315
316         /* Create an AESNI GCM device if required */
317         if (gbl_driver_id == rte_cryptodev_driver_id_get(
318                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
319                 nb_devs = rte_cryptodev_device_count_by_driver(
320                                 rte_cryptodev_driver_id_get(
321                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
322                 if (nb_devs < 1) {
323                         ret = rte_vdev_init(
324                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL);
325
326                         TEST_ASSERT(ret == 0,
327                                 "Failed to create instance of pmd : %s",
328                                 RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
329                 }
330         }
331
332         /* Create a SNOW3G device if required */
333         if (gbl_driver_id == rte_cryptodev_driver_id_get(
334                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
335                 nb_devs = rte_cryptodev_device_count_by_driver(
336                                 rte_cryptodev_driver_id_get(
337                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
338                 if (nb_devs < 1) {
339                         ret = rte_vdev_init(
340                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL);
341
342                         TEST_ASSERT(ret == 0,
343                                 "Failed to create instance of pmd : %s",
344                                 RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
345                 }
346         }
347
348         /* Create an OPENSSL device if required */
349         if (gbl_driver_id == rte_cryptodev_driver_id_get(
350                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
351                 nb_devs = rte_cryptodev_device_count_by_driver(
352                                 rte_cryptodev_driver_id_get(
353                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
354                 if (nb_devs < 1) {
355                         ret = rte_vdev_init(
356                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
357                                 NULL);
358
359                         TEST_ASSERT(ret == 0, "Failed to create "
360                                 "instance of pmd : %s",
361                                 RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
362                 }
363         }
364
365         /* Create an ARMv8 device if required */
366         if (gbl_driver_id == rte_cryptodev_driver_id_get(
367                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
368                 nb_devs = rte_cryptodev_device_count_by_driver(
369                                 rte_cryptodev_driver_id_get(
370                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
371                 if (nb_devs < 1) {
372                         ret = rte_vdev_init(
373                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
374                                 NULL);
375
376                         TEST_ASSERT(ret == 0, "Failed to create "
377                                 "instance of pmd : %s",
378                                 RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
379                 }
380         }
381
382         nb_devs = rte_cryptodev_count();
383         if (nb_devs < 1) {
384                 RTE_LOG(ERR, USER1, "No crypto devices found?\n");
385                 return TEST_FAILED;
386         }
387
388         /* Search for the first valid */
389         for (i = 0; i < nb_devs; i++) {
390                 rte_cryptodev_info_get(i, &info);
391                 if (info.driver_id == (uint8_t) gbl_driver_id) {
392                         ts_params->dev_id = i;
393                         valid_dev_id = 1;
394                         break;
395                 }
396         }
397
398         if (!valid_dev_id)
399                 return TEST_FAILED;
400
401         /*
402          * Using Crypto Device Id 0 by default.
403          * Set up all the qps on this device
404          */
405
406         rte_cryptodev_info_get(ts_params->dev_id, &info);
407
408         ts_params->conf.nb_queue_pairs = info.max_nb_queue_pairs;
409         ts_params->conf.socket_id = SOCKET_ID_ANY;
410
411         unsigned int session_size = sizeof(struct rte_cryptodev_sym_session) +
412                 rte_cryptodev_get_private_session_size(ts_params->dev_id);
413
414         ts_params->sess_mp = rte_mempool_create(
415                                 "test_sess_mp_perf",
416                                 info.sym.max_nb_sessions,
417                                 session_size,
418                                 0, 0, NULL, NULL, NULL,
419                                 NULL, SOCKET_ID_ANY,
420                                 0);
421
422         TEST_ASSERT_NOT_NULL(ts_params->sess_mp,
423                         "session mempool allocation failed");
424
425         TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->dev_id,
426                         &ts_params->conf),
427                         "Failed to configure cryptodev %u",
428                         ts_params->dev_id);
429
430         ts_params->qp_conf.nb_descriptors = PERF_NUM_OPS_INFLIGHT;
431         for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
432
433                 TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
434                         ts_params->dev_id, qp_id,
435                                 &ts_params->qp_conf,
436                                 rte_cryptodev_socket_id(ts_params->dev_id),
437                                 ts_params->sess_mp),
438                                 "Failed to setup queue pair %u on cryptodev %u",
439                                 qp_id, ts_params->dev_id);
440         }
441
442         return TEST_SUCCESS;
443 }
444 static void
445 testsuite_teardown(void)
446 {
447         struct crypto_testsuite_params *ts_params =
448                         &testsuite_params;
449
450         if (ts_params->mbuf_mp != NULL)
451                 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
452                 rte_mempool_avail_count(ts_params->mbuf_mp));
453         if (ts_params->op_mpool != NULL)
454                 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_OP POOL count %u\n",
455                 rte_mempool_avail_count(ts_params->op_mpool));
456         /* Free session mempool */
457         if (ts_params->sess_mp != NULL) {
458                 rte_mempool_free(ts_params->sess_mp);
459                 ts_params->sess_mp = NULL;
460         }
461
462 }
463
464 static int
465 ut_setup(void)
466 {
467         struct crypto_testsuite_params *ts_params = &testsuite_params;
468         struct crypto_unittest_params *ut_params = &unittest_params;
469
470         /* Clear unit test parameters before running test */
471         memset(ut_params, 0, sizeof(*ut_params));
472
473         rte_cryptodev_stats_reset(ts_params->dev_id);
474
475         /* Start the device */
476         TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->dev_id),
477                         "Failed to start cryptodev %u",
478                         ts_params->dev_id);
479
480         return TEST_SUCCESS;
481 }
482
483 static void
484 ut_teardown(void)
485 {
486         struct crypto_testsuite_params *ts_params = &testsuite_params;
487         struct crypto_unittest_params *ut_params = &unittest_params;
488         struct rte_cryptodev_stats stats;
489
490         unsigned i;
491
492         /* free crypto session structure */
493         if (ut_params->sess) {
494                 rte_cryptodev_sym_session_clear(ts_params->dev_id,
495                                 ut_params->sess);
496                 rte_cryptodev_sym_session_free(ut_params->sess);
497         }
498
499         /* free crypto operation structure */
500         if (ut_params->op)
501                 rte_crypto_op_free(ut_params->op);
502
503         for (i = 0; i < MAX_NUM_OF_OPS_PER_UT; i++) {
504                 if (ut_params->obuf[i])
505                         rte_pktmbuf_free(ut_params->obuf[i]);
506                 else if (ut_params->ibuf[i])
507                         rte_pktmbuf_free(ut_params->ibuf[i]);
508         }
509
510         if (ts_params->mbuf_mp != NULL)
511                 RTE_LOG(DEBUG, USER1, "CRYPTO_PERF_MBUFPOOL count %u\n",
512                         rte_mempool_avail_count(ts_params->mbuf_mp));
513
514         rte_cryptodev_stats_get(ts_params->dev_id, &stats);
515
516         /* Stop the device */
517         rte_cryptodev_stop(ts_params->dev_id);
518 }
519
520 const char plaintext_quote[] =
521                 "THE COUNT OF MONTE CRISTO by Alexandre Dumas, Pere Chapter 1. "
522                 "Marseilles--The Arrival. On the 24th of February, 1815, the "
523                 "look-out at Notre-Dame de la Garde signalled the three-master,"
524                 " the Pharaon from Smyrna, Trieste, and Naples. As usual, a "
525                 "pilot put off immediately, and rounding the Chateau d'If, got "
526                 "on board the vessel between Cape Morgion and Rion island. "
527                 "Immediately, and according to custom, the ramparts of Fort "
528                 "Saint-Jean were covered with spectators; it is always an event "
529                 "at Marseilles for a ship to come into port, especially when "
530                 "this ship, like the Pharaon, has been built, rigged, and laden"
531                 " at the old Phocee docks, and belongs to an owner of the city."
532                 " The ship drew on and had safely passed the strait, which some"
533                 " volcanic shock has made between the Calasareigne and Jaros "
534                 "islands; had doubled Pomegue, and approached the harbor under"
535                 " topsails, jib, and spanker, but so slowly and sedately that"
536                 " the idlers, with that instinct which is the forerunner of "
537                 "evil, asked one another what misfortune could have happened "
538                 "on board. However, those experienced in navigation saw plainly"
539                 " that if any accident had occurred, it was not to the vessel "
540                 "herself, for she bore down with all the evidence of being "
541                 "skilfully handled, the anchor a-cockbill, the jib-boom guys "
542                 "already eased off, and standing by the side of the pilot, who"
543                 " was steering the Pharaon towards the narrow entrance of the"
544                 " inner port, was a young man, who, with activity and vigilant"
545                 " eye, watched every motion of the ship, and repeated each "
546                 "direction of the pilot. The vague disquietude which prevailed "
547                 "among the spectators had so much affected one of the crowd "
548                 "that he did not await the arrival of the vessel in harbor, but"
549                 " jumping into a small skiff, desired to be pulled alongside "
550                 "the Pharaon, which he reached as she rounded into La Reserve "
551                 "basin. When the young man on board saw this person approach, "
552                 "he left his station by the pilot, and, hat in hand, leaned "
553                 "over the ship's bulwarks. He was a fine, tall, slim young "
554                 "fellow of eighteen or twenty, with black eyes, and hair as "
555                 "dark as a raven's wing; and his whole appearance bespoke that "
556                 "calmness and resolution peculiar to men accustomed from their "
557                 "cradle to contend with danger. \"Ah, is it you, Dantes?\" "
558                 "cried the man in the skiff. \"What's the matter? and why have "
559                 "you such an air of sadness aboard?\" \"A great misfortune, M. "
560                 "Morrel,\" replied the young man,--\"a great misfortune, for me"
561                 " especially! Off Civita Vecchia we lost our brave Captain "
562                 "Leclere.\" \"And the cargo?\" inquired the owner, eagerly. "
563                 "\"Is all safe, M. Morrel; and I think you will be satisfied on"
564                 " that head. But poor Captain Leclere--\" \"What happened to "
565                 "him?\" asked the owner, with an air of considerable "
566                 "resignation. \"What happened to the worthy captain?\" \"He "
567                 "died.\" \"Fell into the sea?\" \"No, sir, he died of "
568                 "brain-fever in dreadful agony.\" Then turning to the crew, "
569                 "he said, \"Bear a hand there, to take in sail!\" All hands "
570                 "obeyed, and at once the eight or ten seamen who composed the "
571                 "crew, sprang to their respective stations at the spanker "
572                 "brails and outhaul, topsail sheets and halyards, the jib "
573                 "downhaul, and the topsail clewlines and buntlines. The young "
574                 "sailor gave a look to see that his orders were promptly and "
575                 "accurately obeyed, and then turned again to the owner. \"And "
576                 "how did this misfortune occur?\" inquired the latter, resuming"
577                 " the interrupted conversation. \"Alas, sir, in the most "
578                 "unexpected manner. After a long talk with the harbor-master, "
579                 "Captain Leclere left Naples greatly disturbed in mind. In "
580                 "twenty-four hours he was attacked by a fever, and died three "
581                 "days afterwards. We performed the usual burial service, and he"
582                 " is at his rest, sewn up in his hammock with a thirty-six "
583                 "pound shot at his head and his heels, off El Giglio island. "
584                 "We bring to his widow his sword and cross of honor. It was "
585                 "worth while, truly,\" added the young man with a melancholy "
586                 "smile, \"to make war against the English for ten years, and "
587                 "to die in his bed at last, like everybody else.";
588
589 #define QUOTE_LEN_64B           (64)
590 #define QUOTE_LEN_128B          (128)
591 #define QUOTE_LEN_256B          (256)
592 #define QUOTE_LEN_512B          (512)
593 #define QUOTE_LEN_768B          (768)
594 #define QUOTE_LEN_1024B         (1024)
595 #define QUOTE_LEN_1280B         (1280)
596 #define QUOTE_LEN_1536B         (1536)
597 #define QUOTE_LEN_1792B         (1792)
598 #define QUOTE_LEN_2048B         (2048)
599
600
601 /* ***** AES-CBC / HMAC-SHA256 Performance Tests ***** */
602
603 #define HMAC_KEY_LENGTH_SHA256  (DIGEST_BYTE_LENGTH_SHA256)
604
605 #define CIPHER_KEY_LENGTH_AES_CBC       (16)
606 #define CIPHER_IV_LENGTH_AES_CBC        (CIPHER_KEY_LENGTH_AES_CBC)
607
608 static uint8_t aes_cbc_128_key[] = {
609                 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
610                 0xF1, 0x35, 0x5C, 0x3B, 0xDD, 0x9A, 0x65, 0xBA };
611
612 static uint8_t aes_cbc_128_iv[] = {
613                 0xf5, 0xd3, 0x89, 0x0f, 0x47, 0x00, 0xcb, 0x52,
614                 0x42, 0x1a, 0x7d, 0x3d, 0xf5, 0x82, 0x80, 0xf1 };
615
616 static uint8_t hmac_sha256_key[] = {
617                 0xff, 0xcb, 0x37, 0x30, 0x1d, 0x4a, 0xc2, 0x41,
618                 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
619                 0x58, 0x34, 0x85, 0x61, 0x1C, 0x42, 0x10, 0x76,
620                 0x9a, 0x4f, 0x88, 0x1b, 0xb6, 0x8f, 0xd8, 0x60 };
621
622
623 /* Cipher text output */
624
625 static const uint8_t AES_CBC_ciphertext_64B[] = {
626                 0x05, 0x15, 0x77, 0x32, 0xc9, 0x66, 0x91, 0x50,
627                 0x93, 0x9f, 0xbb, 0x4e, 0x2e, 0x5a, 0x02, 0xd0,
628                 0x2d, 0x9d, 0x31, 0x5d, 0xc8, 0x9e, 0x86, 0x36,
629                 0x54, 0x5c, 0x50, 0xe8, 0x75, 0x54, 0x74, 0x5e,
630                 0xd5, 0xa2, 0x84, 0x21, 0x2d, 0xc5, 0xf8, 0x1c,
631                 0x55, 0x1a, 0xba, 0x91, 0xce, 0xb5, 0xa3, 0x1e,
632                 0x31, 0xbf, 0xe9, 0xa1, 0x97, 0x5c, 0x2b, 0xd6,
633                 0x57, 0xa5, 0x9f, 0xab, 0xbd, 0xb0, 0x9b, 0x9c
634 };
635
636 static const uint8_t AES_CBC_ciphertext_128B[] = {
637                 0x79, 0x92, 0x65, 0xc8, 0xfb, 0x0a, 0xc7, 0xc4,
638                 0x9b, 0x3b, 0xbe, 0x69, 0x7f, 0x7c, 0xf4, 0x4e,
639                 0xa5, 0x0d, 0xf6, 0x33, 0xc4, 0xdf, 0xf3, 0x0d,
640                 0xdb, 0xb9, 0x68, 0x34, 0xb0, 0x0d, 0xbd, 0xb9,
641                 0xa7, 0xf3, 0x86, 0x50, 0x2a, 0xbe, 0x50, 0x5d,
642                 0xb3, 0xbe, 0x72, 0xf9, 0x02, 0xb1, 0x69, 0x0b,
643                 0x8c, 0x96, 0x4c, 0x3c, 0x0c, 0x1e, 0x76, 0xe5,
644                 0x7e, 0x75, 0xdd, 0xd0, 0xa9, 0x75, 0x00, 0x13,
645                 0x6b, 0x1e, 0xc0, 0xad, 0xfc, 0x03, 0xb5, 0x99,
646                 0xdc, 0x37, 0x35, 0xfc, 0x16, 0x34, 0xfd, 0xb4,
647                 0xea, 0x1e, 0xb6, 0x51, 0xdf, 0xab, 0x87, 0xd6,
648                 0x87, 0x41, 0xfa, 0x1c, 0xc6, 0x78, 0xa6, 0x3c,
649                 0x1d, 0x76, 0xfe, 0xff, 0x65, 0xfc, 0x63, 0x1e,
650                 0x1f, 0xe2, 0x7c, 0x9b, 0xa2, 0x72, 0xc3, 0x34,
651                 0x23, 0xdf, 0x01, 0xf0, 0xfd, 0x02, 0x8b, 0x97,
652                 0x00, 0x2b, 0x97, 0x4e, 0xab, 0x98, 0x21, 0x3c
653 };
654
655 static const uint8_t AES_CBC_ciphertext_256B[] = {
656                 0xc7, 0x71, 0x2b, 0xed, 0x2c, 0x97, 0x59, 0xfa,
657                 0xcf, 0x5a, 0xb9, 0x31, 0x92, 0xe0, 0xc9, 0x92,
658                 0xc0, 0x2d, 0xd5, 0x9c, 0x84, 0xbf, 0x70, 0x36,
659                 0x13, 0x48, 0xe0, 0xb1, 0xbf, 0x6c, 0xcd, 0x91,
660                 0xa0, 0xc3, 0x57, 0x6c, 0x3f, 0x0e, 0x34, 0x41,
661                 0xe7, 0x9c, 0xc0, 0xec, 0x18, 0x0c, 0x05, 0x52,
662                 0x78, 0xe2, 0x3c, 0x6e, 0xdf, 0xa5, 0x49, 0xc7,
663                 0xf2, 0x55, 0x00, 0x8f, 0x65, 0x6d, 0x4b, 0xd0,
664                 0xcb, 0xd4, 0xd2, 0x0b, 0xea, 0xf4, 0xb0, 0x85,
665                 0x61, 0x9e, 0x36, 0xc0, 0x71, 0xb7, 0x80, 0xad,
666                 0x40, 0x78, 0xb4, 0x70, 0x2b, 0xe8, 0x80, 0xc5,
667                 0x19, 0x35, 0x96, 0x55, 0x3b, 0x40, 0x03, 0xbb,
668                 0x9f, 0xa6, 0xc2, 0x82, 0x92, 0x04, 0xc3, 0xa6,
669                 0x96, 0xc4, 0x7f, 0x4c, 0x3e, 0x3c, 0x79, 0x82,
670                 0x88, 0x8b, 0x3f, 0x8b, 0xc5, 0x9f, 0x44, 0xbe,
671                 0x71, 0xe7, 0x09, 0xa2, 0x40, 0xa2, 0x23, 0x4e,
672                 0x9f, 0x31, 0xab, 0x6f, 0xdf, 0x59, 0x40, 0xe1,
673                 0x12, 0x15, 0x55, 0x4b, 0xea, 0x3f, 0xa1, 0x41,
674                 0x4f, 0xaf, 0xcd, 0x27, 0x2a, 0x61, 0xa1, 0x9e,
675                 0x82, 0x30, 0x05, 0x05, 0x55, 0xce, 0x99, 0xd3,
676                 0x8f, 0x3f, 0x86, 0x79, 0xdc, 0x9f, 0x33, 0x07,
677                 0x75, 0x26, 0xc8, 0x72, 0x81, 0x0f, 0x9b, 0xf7,
678                 0xb1, 0xfb, 0xd3, 0x91, 0x36, 0x08, 0xab, 0x26,
679                 0x70, 0x53, 0x0c, 0x99, 0xfd, 0xa9, 0x07, 0xb4,
680                 0xe9, 0xce, 0xc1, 0xd6, 0xd2, 0x2c, 0x71, 0x80,
681                 0xec, 0x59, 0x61, 0x0b, 0x24, 0xf0, 0x6d, 0x33,
682                 0x73, 0x45, 0x6e, 0x80, 0x03, 0x45, 0xf2, 0x76,
683                 0xa5, 0x8a, 0xc9, 0xcf, 0xaf, 0x4a, 0xed, 0x35,
684                 0xc0, 0x97, 0x52, 0xc5, 0x00, 0xdf, 0xef, 0xc7,
685                 0x9f, 0xf2, 0xe8, 0x15, 0x3e, 0xb3, 0x30, 0xe7,
686                 0x00, 0xd0, 0x4e, 0xeb, 0x79, 0xf6, 0xf6, 0xcf,
687                 0xf0, 0xe7, 0x61, 0xd5, 0x3d, 0x6a, 0x73, 0x9d
688 };
689
690 static const uint8_t AES_CBC_ciphertext_512B[] = {
691                 0xb4, 0xc6, 0xc6, 0x5f, 0x7e, 0xca, 0x05, 0x70,
692                 0x21, 0x7b, 0x92, 0x9e, 0x23, 0xe7, 0x92, 0xb8,
693                 0x27, 0x3d, 0x20, 0x29, 0x57, 0xfa, 0x1f, 0x26,
694                 0x0a, 0x04, 0x34, 0xa6, 0xf2, 0xdc, 0x44, 0xb6,
695                 0x43, 0x40, 0x62, 0xde, 0x0c, 0xde, 0x1c, 0x30,
696                 0x43, 0x85, 0x0b, 0xe8, 0x93, 0x1f, 0xa1, 0x2a,
697                 0x8a, 0x27, 0x35, 0x39, 0x14, 0x9f, 0x37, 0x64,
698                 0x59, 0xb5, 0x0e, 0x96, 0x82, 0x5d, 0x63, 0x45,
699                 0xd6, 0x93, 0x89, 0x46, 0xe4, 0x71, 0x31, 0xeb,
700                 0x0e, 0xd1, 0x7b, 0xda, 0x90, 0xb5, 0x81, 0xac,
701                 0x76, 0x54, 0x54, 0x85, 0x0b, 0xa9, 0x46, 0x9c,
702                 0xf0, 0xfd, 0xde, 0x5d, 0xa8, 0xe3, 0xee, 0xe9,
703                 0xf4, 0x9d, 0x34, 0x76, 0x39, 0xe7, 0xc3, 0x4a,
704                 0x84, 0x38, 0x92, 0x61, 0xf1, 0x12, 0x9f, 0x05,
705                 0xda, 0xdb, 0xc1, 0xd4, 0xb0, 0xa0, 0x27, 0x19,
706                 0xa0, 0x56, 0x5d, 0x9b, 0xcc, 0x47, 0x7c, 0x15,
707                 0x1d, 0x52, 0x66, 0xd5, 0xff, 0xef, 0x12, 0x23,
708                 0x86, 0xe2, 0xee, 0x81, 0x2c, 0x3d, 0x7d, 0x28,
709                 0xd5, 0x42, 0xdf, 0xdb, 0x75, 0x1c, 0xeb, 0xdf,
710                 0x13, 0x23, 0xd5, 0x17, 0x89, 0xea, 0xd7, 0x01,
711                 0xff, 0x57, 0x6a, 0x44, 0x61, 0xf4, 0xea, 0xbe,
712                 0x97, 0x9b, 0xc2, 0xb1, 0x9c, 0x5d, 0xff, 0x4f,
713                 0x73, 0x2d, 0x3f, 0x57, 0x28, 0x38, 0xbf, 0x3d,
714                 0x9f, 0xda, 0x49, 0x55, 0x8f, 0xb2, 0x77, 0xec,
715                 0x0f, 0xbc, 0xce, 0xb8, 0xc6, 0xe1, 0x03, 0xed,
716                 0x35, 0x9c, 0xf2, 0x4d, 0xa4, 0x29, 0x6c, 0xd6,
717                 0x6e, 0x05, 0x53, 0x46, 0xc1, 0x41, 0x09, 0x36,
718                 0x0b, 0x7d, 0xf4, 0x9e, 0x0f, 0xba, 0x86, 0x33,
719                 0xdd, 0xf1, 0xa7, 0xf7, 0xd5, 0x29, 0xa8, 0xa7,
720                 0x4d, 0xce, 0x0c, 0xf5, 0xb4, 0x6c, 0xd8, 0x27,
721                 0xb0, 0x87, 0x2a, 0x6f, 0x7f, 0x3f, 0x8f, 0xc3,
722                 0xe2, 0x3e, 0x94, 0xcf, 0x61, 0x4a, 0x09, 0x3d,
723                 0xf9, 0x55, 0x19, 0x31, 0xf2, 0xd2, 0x4a, 0x3e,
724                 0xc1, 0xf5, 0xed, 0x7c, 0x45, 0xb0, 0x0c, 0x7b,
725                 0xdd, 0xa6, 0x0a, 0x26, 0x66, 0xec, 0x85, 0x49,
726                 0x00, 0x38, 0x05, 0x7c, 0x9c, 0x1c, 0x92, 0xf5,
727                 0xf7, 0xdb, 0x5d, 0xbd, 0x61, 0x0c, 0xc9, 0xaf,
728                 0xfd, 0x57, 0x3f, 0xee, 0x2b, 0xad, 0x73, 0xef,
729                 0xa3, 0xc1, 0x66, 0x26, 0x44, 0x5e, 0xf9, 0x12,
730                 0x86, 0x66, 0xa9, 0x61, 0x75, 0xa1, 0xbc, 0x40,
731                 0x7f, 0xa8, 0x08, 0x02, 0xc0, 0x76, 0x0e, 0x76,
732                 0xb3, 0x26, 0x3d, 0x1c, 0x40, 0x65, 0xe4, 0x18,
733                 0x0f, 0x62, 0x17, 0x8f, 0x1e, 0x61, 0xb8, 0x08,
734                 0x83, 0x54, 0x42, 0x11, 0x03, 0x30, 0x8e, 0xb7,
735                 0xc1, 0x9c, 0xec, 0x69, 0x52, 0x95, 0xfb, 0x7b,
736                 0x1a, 0x0c, 0x20, 0x24, 0xf7, 0xb8, 0x38, 0x0c,
737                 0xb8, 0x7b, 0xb6, 0x69, 0x70, 0xd0, 0x61, 0xb9,
738                 0x70, 0x06, 0xc2, 0x5b, 0x20, 0x47, 0xf7, 0xd9,
739                 0x32, 0xc2, 0xf2, 0x90, 0xb6, 0x4d, 0xcd, 0x3c,
740                 0x6d, 0x74, 0xea, 0x82, 0x35, 0x1b, 0x08, 0x44,
741                 0xba, 0xb7, 0x33, 0x82, 0x33, 0x27, 0x54, 0x77,
742                 0x6e, 0x58, 0xfe, 0x46, 0x5a, 0xb4, 0x88, 0x53,
743                 0x8d, 0x9b, 0xb1, 0xab, 0xdf, 0x04, 0xe1, 0xfb,
744                 0xd7, 0x1e, 0xd7, 0x38, 0x64, 0x54, 0xba, 0xb0,
745                 0x6c, 0x84, 0x7a, 0x0f, 0xa7, 0x80, 0x6b, 0x86,
746                 0xd9, 0xc9, 0xc6, 0x31, 0x95, 0xfa, 0x8a, 0x2c,
747                 0x14, 0xe1, 0x85, 0x66, 0x27, 0xfd, 0x63, 0x3e,
748                 0xf0, 0xfa, 0x81, 0xc9, 0x89, 0x4f, 0xe2, 0x6a,
749                 0x8c, 0x17, 0xb5, 0xc7, 0x9f, 0x5d, 0x3f, 0x6b,
750                 0x3f, 0xcd, 0x13, 0x7a, 0x3c, 0xe6, 0x4e, 0xfa,
751                 0x7a, 0x10, 0xb8, 0x7c, 0x40, 0xec, 0x93, 0x11,
752                 0x1f, 0xd0, 0x9e, 0xc3, 0x56, 0xb9, 0xf5, 0x21,
753                 0x18, 0x41, 0x31, 0xea, 0x01, 0x8d, 0xea, 0x1c,
754                 0x95, 0x5e, 0x56, 0x33, 0xbc, 0x7a, 0x3f, 0x6f
755 };
756
757 static const uint8_t AES_CBC_ciphertext_768B[] = {
758                 0x3e, 0x7f, 0x9e, 0x4c, 0x88, 0x15, 0x68, 0x69,
759                 0x10, 0x09, 0xe1, 0xa7, 0x0f, 0x27, 0x88, 0x2d,
760                 0x90, 0x73, 0x4f, 0x67, 0xd3, 0x8b, 0xaf, 0xa1,
761                 0x2c, 0x37, 0xa5, 0x6c, 0x7c, 0xbd, 0x95, 0x4c,
762                 0x82, 0xcf, 0x05, 0x49, 0x16, 0x5c, 0xe7, 0x06,
763                 0xd4, 0xcb, 0x55, 0x65, 0x9a, 0xd0, 0xe1, 0x46,
764                 0x3a, 0x37, 0x71, 0xad, 0xb0, 0xb4, 0x99, 0x1e,
765                 0x23, 0x57, 0x48, 0x96, 0x9c, 0xc5, 0xc4, 0xdb,
766                 0x64, 0x3e, 0xc9, 0x7f, 0x90, 0x5a, 0xa0, 0x08,
767                 0x75, 0x4c, 0x09, 0x06, 0x31, 0x6e, 0x59, 0x29,
768                 0xfc, 0x2f, 0x72, 0xde, 0xf2, 0x40, 0x5a, 0xfe,
769                 0xd3, 0x66, 0x64, 0xb8, 0x9c, 0xc9, 0xa6, 0x1f,
770                 0xc3, 0x52, 0xcd, 0xb5, 0xd1, 0x4f, 0x43, 0x3f,
771                 0xf4, 0x59, 0x25, 0xc4, 0xdd, 0x3e, 0x58, 0x7c,
772                 0x21, 0xd6, 0x21, 0xce, 0xa4, 0xbe, 0x08, 0x23,
773                 0x46, 0x68, 0xc0, 0x00, 0x91, 0x47, 0xca, 0x9b,
774                 0xe0, 0xb4, 0xe3, 0xab, 0xbf, 0xcf, 0x68, 0x26,
775                 0x97, 0x23, 0x09, 0x93, 0x64, 0x8f, 0x57, 0x59,
776                 0xe2, 0x41, 0x7c, 0xa2, 0x48, 0x7e, 0xd5, 0x2c,
777                 0x54, 0x09, 0x1b, 0x07, 0x94, 0xca, 0x39, 0x83,
778                 0xdd, 0xf4, 0x7a, 0x1d, 0x2d, 0xdd, 0x67, 0xf7,
779                 0x3c, 0x30, 0x89, 0x3e, 0xc1, 0xdc, 0x1d, 0x8f,
780                 0xfc, 0xb1, 0xe9, 0x13, 0x31, 0xb0, 0x16, 0xdb,
781                 0x88, 0xf2, 0x32, 0x7e, 0x73, 0xa3, 0xdf, 0x08,
782                 0x6b, 0x53, 0x92, 0x08, 0xc9, 0x9d, 0x98, 0xb2,
783                 0xf4, 0x8c, 0xb1, 0x95, 0xdc, 0xb6, 0xfc, 0xec,
784                 0xf1, 0xc9, 0x0d, 0x6d, 0x42, 0x2c, 0xf5, 0x38,
785                 0x29, 0xf4, 0xd8, 0x98, 0x0f, 0xb0, 0x81, 0xa5,
786                 0xaa, 0xe6, 0x1f, 0x6e, 0x87, 0x32, 0x1b, 0x02,
787                 0x07, 0x57, 0x38, 0x83, 0xf3, 0xe4, 0x54, 0x7c,
788                 0xa8, 0x43, 0xdf, 0x3f, 0x42, 0xfd, 0x67, 0x28,
789                 0x06, 0x4d, 0xea, 0xce, 0x1f, 0x84, 0x4a, 0xcd,
790                 0x8c, 0x61, 0x5e, 0x8f, 0x61, 0xed, 0x84, 0x03,
791                 0x53, 0x6a, 0x9e, 0xbf, 0x68, 0x83, 0xa7, 0x42,
792                 0x56, 0x57, 0xcd, 0x45, 0x29, 0xfc, 0x7b, 0x07,
793                 0xfc, 0xe9, 0xb9, 0x42, 0xfd, 0x29, 0xd5, 0xfd,
794                 0x98, 0x11, 0xd1, 0x8d, 0x67, 0x29, 0x47, 0x61,
795                 0xd8, 0x27, 0x37, 0x79, 0x29, 0xd1, 0x94, 0x6f,
796                 0x8d, 0xf3, 0x1b, 0x3d, 0x6a, 0xb1, 0x59, 0xef,
797                 0x1b, 0xd4, 0x70, 0x0e, 0xac, 0xab, 0xa0, 0x2b,
798                 0x1f, 0x5e, 0x04, 0xf0, 0x0e, 0x35, 0x72, 0x90,
799                 0xfc, 0xcf, 0x86, 0x43, 0xea, 0x45, 0x6d, 0x22,
800                 0x63, 0x06, 0x1a, 0x58, 0xd7, 0x2d, 0xc5, 0xb0,
801                 0x60, 0x69, 0xe8, 0x53, 0xc2, 0xa2, 0x57, 0x83,
802                 0xc4, 0x31, 0xb4, 0xc6, 0xb3, 0xa1, 0x77, 0xb3,
803                 0x1c, 0xca, 0x89, 0x3f, 0xf5, 0x10, 0x3b, 0x36,
804                 0x31, 0x7d, 0x00, 0x46, 0x00, 0x92, 0xa0, 0xa0,
805                 0x34, 0xd8, 0x5e, 0x62, 0xa9, 0xe0, 0x23, 0x37,
806                 0x50, 0x85, 0xc7, 0x3a, 0x20, 0xa3, 0x98, 0xc0,
807                 0xac, 0x20, 0x06, 0x0f, 0x17, 0x3c, 0xfc, 0x43,
808                 0x8c, 0x9d, 0xec, 0xf5, 0x9a, 0x35, 0x96, 0xf7,
809                 0xb7, 0x4c, 0xf9, 0x69, 0xf8, 0xd4, 0x1e, 0x9e,
810                 0xf9, 0x7c, 0xc4, 0xd2, 0x11, 0x14, 0x41, 0xb9,
811                 0x89, 0xd6, 0x07, 0xd2, 0x37, 0x07, 0x5e, 0x5e,
812                 0xae, 0x60, 0xdc, 0xe4, 0xeb, 0x38, 0x48, 0x6d,
813                 0x95, 0x8d, 0x71, 0xf2, 0xba, 0xda, 0x5f, 0x08,
814                 0x9d, 0x4a, 0x0f, 0x56, 0x90, 0x64, 0xab, 0xb6,
815                 0x88, 0x22, 0xa8, 0x90, 0x1f, 0x76, 0x2c, 0x83,
816                 0x43, 0xce, 0x32, 0x55, 0x45, 0x84, 0x57, 0x43,
817                 0xf9, 0xa8, 0xd1, 0x4f, 0xe3, 0xc1, 0x72, 0x9c,
818                 0xeb, 0x64, 0xf7, 0xe4, 0x61, 0x2b, 0x93, 0xd1,
819                 0x1f, 0xbb, 0x5c, 0xff, 0xa1, 0x59, 0x69, 0xcf,
820                 0xf7, 0xaf, 0x58, 0x45, 0xd5, 0x3e, 0x98, 0x7d,
821                 0x26, 0x39, 0x5c, 0x75, 0x3c, 0x4a, 0xbf, 0x5e,
822                 0x12, 0x10, 0xb0, 0x93, 0x0f, 0x86, 0x82, 0xcf,
823                 0xb2, 0xec, 0x70, 0x5c, 0x0b, 0xad, 0x5d, 0x63,
824                 0x65, 0x32, 0xa6, 0x04, 0x58, 0x03, 0x91, 0x2b,
825                 0xdb, 0x8f, 0xd3, 0xa3, 0x2b, 0x3a, 0xf5, 0xa1,
826                 0x62, 0x6c, 0xb6, 0xf0, 0x13, 0x3b, 0x8c, 0x07,
827                 0x10, 0x82, 0xc9, 0x56, 0x24, 0x87, 0xfc, 0x56,
828                 0xe8, 0xef, 0x90, 0x8b, 0xd6, 0x48, 0xda, 0x53,
829                 0x04, 0x49, 0x41, 0xa4, 0x67, 0xe0, 0x33, 0x24,
830                 0x6b, 0x9c, 0x07, 0x55, 0x4c, 0x5d, 0xe9, 0x35,
831                 0xfa, 0xbd, 0xea, 0xa8, 0x3f, 0xe9, 0xf5, 0x20,
832                 0x5c, 0x60, 0x0f, 0x0d, 0x24, 0xcb, 0x1a, 0xd6,
833                 0xe8, 0x5c, 0xa8, 0x42, 0xae, 0xd0, 0xd2, 0xf2,
834                 0xa8, 0xbe, 0xea, 0x0f, 0x8d, 0xfb, 0x81, 0xa3,
835                 0xa4, 0xef, 0xb7, 0x3e, 0x91, 0xbd, 0x26, 0x0f,
836                 0x8e, 0xf1, 0xb2, 0xa5, 0x47, 0x06, 0xfa, 0x40,
837                 0x8b, 0x31, 0x7a, 0x5a, 0x74, 0x2a, 0x0a, 0x7c,
838                 0x62, 0x5d, 0x39, 0xa4, 0xae, 0x14, 0x85, 0x08,
839                 0x5b, 0x20, 0x85, 0xf1, 0x57, 0x6e, 0x71, 0x13,
840                 0x4e, 0x2b, 0x49, 0x87, 0x01, 0xdf, 0x37, 0xed,
841                 0x28, 0xee, 0x4d, 0xa1, 0xf4, 0xb3, 0x3b, 0xba,
842                 0x2d, 0xb3, 0x46, 0x17, 0x84, 0x80, 0x9d, 0xd7,
843                 0x93, 0x1f, 0x28, 0x7c, 0xf5, 0xf9, 0xd6, 0x85,
844                 0x8c, 0xa5, 0x44, 0xe9, 0x2c, 0x65, 0x51, 0x5f,
845                 0x53, 0x7a, 0x09, 0xd9, 0x30, 0x16, 0x95, 0x89,
846                 0x9c, 0x0b, 0xef, 0x90, 0x6d, 0x23, 0xd3, 0x48,
847                 0x57, 0x3b, 0x55, 0x69, 0x96, 0xfc, 0xf7, 0x52,
848                 0x92, 0x38, 0x36, 0xbf, 0xa9, 0x0a, 0xbb, 0x68,
849                 0x45, 0x08, 0x25, 0xee, 0x59, 0xfe, 0xee, 0xf2,
850                 0x2c, 0xd4, 0x5f, 0x78, 0x59, 0x0d, 0x90, 0xf1,
851                 0xd7, 0xe4, 0x39, 0x0e, 0x46, 0x36, 0xf5, 0x75,
852                 0x03, 0x3c, 0x28, 0xfb, 0xfa, 0x8f, 0xef, 0xc9,
853                 0x61, 0x00, 0x94, 0xc3, 0xd2, 0x0f, 0xd9, 0xda
854 };
855
856 static const uint8_t AES_CBC_ciphertext_1024B[] = {
857                 0x7d, 0x01, 0x7e, 0x2f, 0x92, 0xb3, 0xea, 0x72,
858                 0x4a, 0x3f, 0x10, 0xf9, 0x2b, 0xb0, 0xd5, 0xb9,
859                 0x19, 0x68, 0x94, 0xe9, 0x93, 0xe9, 0xd5, 0x26,
860                 0x20, 0x44, 0xe2, 0x47, 0x15, 0x8d, 0x75, 0x48,
861                 0x8e, 0xe4, 0x40, 0x81, 0xb5, 0x06, 0xa8, 0xb8,
862                 0x0e, 0x0f, 0x3b, 0xbc, 0x5b, 0xbe, 0x3b, 0xa2,
863                 0x2a, 0x0c, 0x48, 0x98, 0x19, 0xdf, 0xe9, 0x25,
864                 0x75, 0xab, 0x93, 0x44, 0xb1, 0x72, 0x70, 0xbb,
865                 0x20, 0xcf, 0x78, 0xe9, 0x4d, 0xc6, 0xa9, 0xa9,
866                 0x84, 0x78, 0xc5, 0xc0, 0xc4, 0xc9, 0x79, 0x1a,
867                 0xbc, 0x61, 0x25, 0x5f, 0xac, 0x01, 0x03, 0xb7,
868                 0xef, 0x07, 0xf2, 0x62, 0x98, 0xee, 0xe3, 0xad,
869                 0x94, 0x75, 0x30, 0x67, 0xb9, 0x15, 0x00, 0xe7,
870                 0x11, 0x32, 0x2e, 0x6b, 0x55, 0x9f, 0xac, 0x68,
871                 0xde, 0x61, 0x05, 0x80, 0x01, 0xf3, 0xad, 0xab,
872                 0xaf, 0x45, 0xe0, 0xf4, 0x68, 0x5c, 0xc0, 0x52,
873                 0x92, 0xc8, 0x21, 0xb6, 0xf5, 0x8a, 0x1d, 0xbb,
874                 0xfc, 0x4a, 0x11, 0x62, 0xa2, 0xc4, 0xf1, 0x2d,
875                 0x0e, 0xb2, 0xc7, 0x17, 0x34, 0xb4, 0x2a, 0x54,
876                 0x81, 0xc2, 0x1e, 0xcf, 0x51, 0x0a, 0x76, 0x54,
877                 0xf1, 0x48, 0x0d, 0x5c, 0xcd, 0x38, 0x3e, 0x38,
878                 0x3e, 0xf8, 0x46, 0x1d, 0x00, 0xf5, 0x62, 0xe1,
879                 0x5c, 0xb7, 0x8d, 0xce, 0xd0, 0x3f, 0xbb, 0x22,
880                 0xf1, 0xe5, 0xb1, 0xa0, 0x58, 0x5e, 0x3c, 0x0f,
881                 0x15, 0xd1, 0xac, 0x3e, 0xc7, 0x72, 0xc4, 0xde,
882                 0x8b, 0x95, 0x3e, 0x91, 0xf7, 0x1d, 0x04, 0x9a,
883                 0xc8, 0xe4, 0xbf, 0xd3, 0x22, 0xca, 0x4a, 0xdc,
884                 0xb6, 0x16, 0x79, 0x81, 0x75, 0x2f, 0x6b, 0xa7,
885                 0x04, 0x98, 0xa7, 0x4e, 0xc1, 0x19, 0x90, 0x33,
886                 0x33, 0x3c, 0x7f, 0xdd, 0xac, 0x09, 0x0c, 0xc3,
887                 0x91, 0x34, 0x74, 0xab, 0xa5, 0x35, 0x0a, 0x13,
888                 0xc3, 0x56, 0x67, 0x6d, 0x1a, 0x3e, 0xbf, 0x56,
889                 0x06, 0x67, 0x15, 0x5f, 0xfc, 0x8b, 0xa2, 0x3c,
890                 0x5e, 0xaf, 0x56, 0x1f, 0xe3, 0x2e, 0x9d, 0x0a,
891                 0xf9, 0x9b, 0xc7, 0xb5, 0x03, 0x1c, 0x68, 0x99,
892                 0xfa, 0x3c, 0x37, 0x59, 0xc1, 0xf7, 0x6a, 0x83,
893                 0x22, 0xee, 0xca, 0x7f, 0x7d, 0x49, 0xe6, 0x48,
894                 0x84, 0x54, 0x7a, 0xff, 0xb3, 0x72, 0x21, 0xd8,
895                 0x7a, 0x5d, 0xb1, 0x4b, 0xcc, 0x01, 0x6f, 0x90,
896                 0xc6, 0x68, 0x1c, 0x2c, 0xa1, 0xe2, 0x74, 0x40,
897                 0x26, 0x9b, 0x57, 0x53, 0xa3, 0x7c, 0x0b, 0x0d,
898                 0xcf, 0x05, 0x5d, 0x62, 0x4f, 0x75, 0x06, 0x62,
899                 0x1f, 0x26, 0x32, 0xaa, 0x25, 0xcc, 0x26, 0x8d,
900                 0xae, 0x01, 0x47, 0xa3, 0x00, 0x42, 0xe2, 0x4c,
901                 0xee, 0x29, 0xa2, 0x81, 0xa0, 0xfd, 0xeb, 0xff,
902                 0x9a, 0x66, 0x6e, 0x47, 0x5b, 0xab, 0x93, 0x5a,
903                 0x02, 0x6d, 0x6f, 0xf2, 0x6e, 0x02, 0x9d, 0xb1,
904                 0xab, 0x56, 0xdc, 0x8b, 0x9b, 0x17, 0xa8, 0xfb,
905                 0x87, 0x42, 0x7c, 0x91, 0x1e, 0x14, 0xc6, 0x6f,
906                 0xdc, 0xf0, 0x27, 0x30, 0xfa, 0x3f, 0xc4, 0xad,
907                 0x57, 0x85, 0xd2, 0xc9, 0x32, 0x2c, 0x13, 0xa6,
908                 0x04, 0x04, 0x50, 0x05, 0x2f, 0x72, 0xd9, 0x44,
909                 0x55, 0x6e, 0x93, 0x40, 0xed, 0x7e, 0xd4, 0x40,
910                 0x3e, 0x88, 0x3b, 0x8b, 0xb6, 0xeb, 0xc6, 0x5d,
911                 0x9c, 0x99, 0xa1, 0xcf, 0x30, 0xb2, 0xdc, 0x48,
912                 0x8a, 0x01, 0xa7, 0x61, 0x77, 0x50, 0x14, 0xf3,
913                 0x0c, 0x49, 0x53, 0xb3, 0xb4, 0xb4, 0x28, 0x41,
914                 0x4a, 0x2d, 0xd2, 0x4d, 0x2a, 0x30, 0x31, 0x83,
915                 0x03, 0x5e, 0xaa, 0xd3, 0xa3, 0xd1, 0xa1, 0xca,
916                 0x62, 0xf0, 0xe1, 0xf2, 0xff, 0xf0, 0x19, 0xa6,
917                 0xde, 0x22, 0x47, 0xb5, 0x28, 0x7d, 0xf7, 0x07,
918                 0x16, 0x0d, 0xb1, 0x55, 0x81, 0x95, 0xe5, 0x1d,
919                 0x4d, 0x78, 0xa9, 0x3e, 0xce, 0xe3, 0x1c, 0xf9,
920                 0x47, 0xc8, 0xec, 0xc5, 0xc5, 0x93, 0x4c, 0x34,
921                 0x20, 0x6b, 0xee, 0x9a, 0xe6, 0x86, 0x57, 0x58,
922                 0xd5, 0x58, 0xf1, 0x33, 0x10, 0x29, 0x9e, 0x93,
923                 0x2f, 0xf5, 0x90, 0x00, 0x17, 0x67, 0x4f, 0x39,
924                 0x18, 0xe1, 0xcf, 0x55, 0x78, 0xbb, 0xe6, 0x29,
925                 0x3e, 0x77, 0xd5, 0x48, 0xb7, 0x42, 0x72, 0x53,
926                 0x27, 0xfa, 0x5b, 0xe0, 0x36, 0x14, 0x97, 0xb8,
927                 0x9b, 0x3c, 0x09, 0x77, 0xc1, 0x0a, 0xe4, 0xa2,
928                 0x63, 0xfc, 0xbe, 0x5c, 0x17, 0xcf, 0x01, 0xf5,
929                 0x03, 0x0f, 0x17, 0xbc, 0x93, 0xdd, 0x5f, 0xe2,
930                 0xf3, 0x08, 0xa8, 0xb1, 0x85, 0xb6, 0x34, 0x3f,
931                 0x87, 0x42, 0xa5, 0x42, 0x3b, 0x0e, 0xd6, 0x83,
932                 0x6a, 0xfd, 0x5d, 0xc9, 0x67, 0xd5, 0x51, 0xc9,
933                 0x2a, 0x4e, 0x91, 0xb0, 0x59, 0xb2, 0x0f, 0xa2,
934                 0xe6, 0x47, 0x73, 0xc2, 0xa2, 0xae, 0xbb, 0xc8,
935                 0x42, 0xa3, 0x2a, 0x27, 0x29, 0x48, 0x8c, 0x54,
936                 0x6c, 0xec, 0x00, 0x2a, 0x42, 0xa3, 0x7a, 0x0f,
937                 0x12, 0x66, 0x6b, 0x96, 0xf6, 0xd0, 0x56, 0x4f,
938                 0x49, 0x5c, 0x47, 0xec, 0x05, 0x62, 0x54, 0xb2,
939                 0x64, 0x5a, 0x69, 0x1f, 0x19, 0xb4, 0x84, 0x5c,
940                 0xbe, 0x48, 0x8e, 0xfc, 0x58, 0x21, 0xce, 0xfa,
941                 0xaa, 0x84, 0xd2, 0xc1, 0x08, 0xb3, 0x87, 0x0f,
942                 0x4f, 0xa3, 0x3a, 0xb6, 0x44, 0xbe, 0x2e, 0x9a,
943                 0xdd, 0xb5, 0x44, 0x80, 0xca, 0xf4, 0xc3, 0x6e,
944                 0xba, 0x93, 0x77, 0xe0, 0x53, 0xfb, 0x37, 0xfb,
945                 0x88, 0xc3, 0x1f, 0x25, 0xde, 0x3e, 0x11, 0xf4,
946                 0x89, 0xe7, 0xd1, 0x3b, 0xb4, 0x23, 0xcb, 0x70,
947                 0xba, 0x35, 0x97, 0x7c, 0xbe, 0x84, 0x13, 0xcf,
948                 0xe0, 0x4d, 0x33, 0x91, 0x71, 0x85, 0xbb, 0x4b,
949                 0x97, 0x32, 0x5d, 0xa0, 0xb9, 0x8f, 0xdc, 0x27,
950                 0x5a, 0xeb, 0x71, 0xf1, 0xd5, 0x0d, 0x65, 0xb4,
951                 0x22, 0x81, 0xde, 0xa7, 0x58, 0x20, 0x0b, 0x18,
952                 0x11, 0x76, 0x5c, 0xe6, 0x6a, 0x2c, 0x99, 0x69,
953                 0xdc, 0xed, 0x67, 0x08, 0x5d, 0x5e, 0xe9, 0x1e,
954                 0x55, 0x70, 0xc1, 0x5a, 0x76, 0x1b, 0x8d, 0x2e,
955                 0x0d, 0xf9, 0xcc, 0x30, 0x8c, 0x44, 0x0f, 0x63,
956                 0x8c, 0x42, 0x8a, 0x9f, 0x4c, 0xd1, 0x48, 0x28,
957                 0x8a, 0xf5, 0x56, 0x2e, 0x23, 0x12, 0xfe, 0x67,
958                 0x9a, 0x13, 0x65, 0x75, 0x83, 0xf1, 0x3c, 0x98,
959                 0x07, 0x6b, 0xb7, 0x27, 0x5b, 0xf0, 0x70, 0xda,
960                 0x30, 0xf8, 0x74, 0x4e, 0x7a, 0x32, 0x84, 0xcc,
961                 0x0e, 0xcd, 0x80, 0x8b, 0x82, 0x31, 0x9a, 0x48,
962                 0xcf, 0x75, 0x00, 0x1f, 0x4f, 0xe0, 0x8e, 0xa3,
963                 0x6a, 0x2c, 0xd4, 0x73, 0x4c, 0x63, 0x7c, 0xa6,
964                 0x4d, 0x5e, 0xfd, 0x43, 0x3b, 0x27, 0xe1, 0x5e,
965                 0xa3, 0xa9, 0x5c, 0x3b, 0x60, 0xdd, 0xc6, 0x8d,
966                 0x5a, 0xf1, 0x3e, 0x89, 0x4b, 0x24, 0xcf, 0x01,
967                 0x3a, 0x2d, 0x44, 0xe7, 0xda, 0xe7, 0xa1, 0xac,
968                 0x11, 0x05, 0x0c, 0xa9, 0x7a, 0x82, 0x8c, 0x5c,
969                 0x29, 0x68, 0x9c, 0x73, 0x13, 0xcc, 0x67, 0x32,
970                 0x11, 0x5e, 0xe5, 0xcc, 0x8c, 0xf5, 0xa7, 0x52,
971                 0x83, 0x9a, 0x70, 0xef, 0xde, 0x55, 0x9c, 0xc7,
972                 0x8a, 0xed, 0xad, 0x28, 0x4a, 0xc5, 0x92, 0x6d,
973                 0x8e, 0x47, 0xca, 0xe3, 0xf8, 0x77, 0xb5, 0x26,
974                 0x64, 0x84, 0xc2, 0xf1, 0xd7, 0xae, 0x0c, 0xb9,
975                 0x39, 0x0f, 0x43, 0x6b, 0xe9, 0xe0, 0x09, 0x4b,
976                 0xe5, 0xe3, 0x17, 0xa6, 0x68, 0x69, 0x46, 0xf4,
977                 0xf0, 0x68, 0x7f, 0x2f, 0x1c, 0x7e, 0x4c, 0xd2,
978                 0xb5, 0xc6, 0x16, 0x85, 0xcf, 0x02, 0x4c, 0x89,
979                 0x0b, 0x25, 0xb0, 0xeb, 0xf3, 0x77, 0x08, 0x6a,
980                 0x46, 0x5c, 0xf6, 0x2f, 0xf1, 0x24, 0xc3, 0x4d,
981                 0x80, 0x60, 0x4d, 0x69, 0x98, 0xde, 0xc7, 0xa1,
982                 0xf6, 0x4e, 0x18, 0x0c, 0x2a, 0xb0, 0xb2, 0xe0,
983                 0x46, 0xe7, 0x49, 0x37, 0xc8, 0x5a, 0x23, 0x24,
984                 0xe3, 0x0f, 0xcc, 0x92, 0xb4, 0x8d, 0xdc, 0x9e
985 };
986
987 static const uint8_t AES_CBC_ciphertext_1280B[] = {
988                 0x91, 0x99, 0x5e, 0x9e, 0x84, 0xff, 0x59, 0x45,
989                 0xc1, 0xf4, 0xbc, 0x9c, 0xb9, 0x30, 0x6c, 0x51,
990                 0x73, 0x52, 0xb4, 0x44, 0x09, 0x79, 0xe2, 0x89,
991                 0x75, 0xeb, 0x54, 0x26, 0xce, 0xd8, 0x24, 0x98,
992                 0xaa, 0xf8, 0x13, 0x16, 0x68, 0x58, 0xc4, 0x82,
993                 0x0e, 0x31, 0xd3, 0x6a, 0x13, 0x58, 0x31, 0xe9,
994                 0x3a, 0xc1, 0x8b, 0xc5, 0x3f, 0x50, 0x42, 0xd1,
995                 0x93, 0xe4, 0x9b, 0x65, 0x2b, 0xf4, 0x1d, 0x9e,
996                 0x2d, 0xdb, 0x48, 0xef, 0x9a, 0x01, 0x68, 0xb6,
997                 0xea, 0x7a, 0x2b, 0xad, 0xfe, 0x77, 0x44, 0x7e,
998                 0x5a, 0xc5, 0x64, 0xb4, 0xfe, 0x5c, 0x80, 0xf3,
999                 0x20, 0x7e, 0xaf, 0x5b, 0xf8, 0xd1, 0x38, 0xa0,
1000                 0x8d, 0x09, 0x77, 0x06, 0xfe, 0xf5, 0xf4, 0xe4,
1001                 0xee, 0xb8, 0x95, 0x27, 0xed, 0x07, 0xb8, 0xaa,
1002                 0x25, 0xb4, 0xe1, 0x4c, 0xeb, 0x3f, 0xdb, 0x39,
1003                 0x66, 0x28, 0x1b, 0x60, 0x42, 0x8b, 0x99, 0xd9,
1004                 0x49, 0xd6, 0x8c, 0xa4, 0x9d, 0xd8, 0x93, 0x58,
1005                 0x8f, 0xfa, 0xd3, 0xf7, 0x37, 0x9c, 0x88, 0xab,
1006                 0x16, 0x50, 0xfe, 0x01, 0x1f, 0x88, 0x48, 0xbe,
1007                 0x21, 0xa9, 0x90, 0x9e, 0x73, 0xe9, 0x82, 0xf7,
1008                 0xbf, 0x4b, 0x43, 0xf4, 0xbf, 0x22, 0x3c, 0x45,
1009                 0x47, 0x95, 0x5b, 0x49, 0x71, 0x07, 0x1c, 0x8b,
1010                 0x49, 0xa4, 0xa3, 0x49, 0xc4, 0x5f, 0xb1, 0xf5,
1011                 0xe3, 0x6b, 0xf1, 0xdc, 0xea, 0x92, 0x7b, 0x29,
1012                 0x40, 0xc9, 0x39, 0x5f, 0xdb, 0xbd, 0xf3, 0x6a,
1013                 0x09, 0x9b, 0x2a, 0x5e, 0xc7, 0x0b, 0x25, 0x94,
1014                 0x55, 0x71, 0x9c, 0x7e, 0x0e, 0xb4, 0x08, 0x12,
1015                 0x8c, 0x6e, 0x77, 0xb8, 0x29, 0xf1, 0xc6, 0x71,
1016                 0x04, 0x40, 0x77, 0x18, 0x3f, 0x01, 0x09, 0x9c,
1017                 0x23, 0x2b, 0x5d, 0x2a, 0x88, 0x20, 0x23, 0x59,
1018                 0x74, 0x2a, 0x67, 0x8f, 0xb7, 0xba, 0x38, 0x9f,
1019                 0x0f, 0xcf, 0x94, 0xdf, 0xe1, 0x8f, 0x35, 0x5e,
1020                 0x34, 0x0c, 0x32, 0x92, 0x2b, 0x23, 0x81, 0xf4,
1021                 0x73, 0xa0, 0x5a, 0x2a, 0xbd, 0xa6, 0x6b, 0xae,
1022                 0x43, 0xe2, 0xdc, 0x01, 0xc1, 0xc6, 0xc3, 0x04,
1023                 0x06, 0xbb, 0xb0, 0x89, 0xb3, 0x4e, 0xbd, 0x81,
1024                 0x1b, 0x03, 0x63, 0x93, 0xed, 0x4e, 0xf6, 0xe5,
1025                 0x94, 0x6f, 0xd6, 0xf3, 0x20, 0xf3, 0xbc, 0x30,
1026                 0xc5, 0xd6, 0xbe, 0x1c, 0x05, 0x34, 0x26, 0x4d,
1027                 0x46, 0x5e, 0x56, 0x63, 0xfb, 0xdb, 0xcd, 0xed,
1028                 0xb0, 0x7f, 0x83, 0x94, 0x55, 0x54, 0x2f, 0xab,
1029                 0xc9, 0xb7, 0x16, 0x4f, 0x9e, 0x93, 0x25, 0xd7,
1030                 0x9f, 0x39, 0x2b, 0x63, 0xcf, 0x1e, 0xa3, 0x0e,
1031                 0x28, 0x47, 0x8a, 0x5f, 0x40, 0x02, 0x89, 0x1f,
1032                 0x83, 0xe7, 0x87, 0xd1, 0x90, 0x17, 0xb8, 0x27,
1033                 0x64, 0xe1, 0xe1, 0x48, 0x5a, 0x55, 0x74, 0x99,
1034                 0x27, 0x9d, 0x05, 0x67, 0xda, 0x70, 0x12, 0x8f,
1035                 0x94, 0x96, 0xfd, 0x36, 0xa4, 0x1d, 0x22, 0xe5,
1036                 0x0b, 0xe5, 0x2f, 0x38, 0x55, 0xa3, 0x5d, 0x0b,
1037                 0xcf, 0xd4, 0xa9, 0xb8, 0xd6, 0x9a, 0x16, 0x2e,
1038                 0x6c, 0x4a, 0x25, 0x51, 0x7a, 0x09, 0x48, 0xdd,
1039                 0xf0, 0xa3, 0x5b, 0x08, 0x1e, 0x2f, 0x03, 0x91,
1040                 0x80, 0xe8, 0x0f, 0xe9, 0x5a, 0x2f, 0x90, 0xd3,
1041                 0x64, 0xed, 0xd7, 0x51, 0x17, 0x66, 0x53, 0x40,
1042                 0x43, 0x74, 0xef, 0x0a, 0x0d, 0x49, 0x41, 0xf2,
1043                 0x67, 0x6e, 0xea, 0x14, 0xc8, 0x74, 0xd6, 0xa9,
1044                 0xb9, 0x6a, 0xe3, 0xec, 0x7d, 0xe8, 0x6a, 0x21,
1045                 0x3a, 0x52, 0x42, 0xfe, 0x9a, 0x15, 0x6d, 0x60,
1046                 0x64, 0x88, 0xc5, 0xb2, 0x8b, 0x15, 0x2c, 0xff,
1047                 0xe2, 0x35, 0xc3, 0xee, 0x9f, 0xcd, 0x82, 0xd9,
1048                 0x14, 0x35, 0x2a, 0xb7, 0xf5, 0x2f, 0x7b, 0xbc,
1049                 0x01, 0xfd, 0xa8, 0xe0, 0x21, 0x4e, 0x73, 0xf9,
1050                 0xf2, 0xb0, 0x79, 0xc9, 0x10, 0x52, 0x8f, 0xa8,
1051                 0x3e, 0x3b, 0xbe, 0xc5, 0xde, 0xf6, 0x53, 0xe3,
1052                 0x1c, 0x25, 0x3a, 0x1f, 0x13, 0xbf, 0x13, 0xbb,
1053                 0x94, 0xc2, 0x97, 0x43, 0x64, 0x47, 0x8f, 0x76,
1054                 0xd7, 0xaa, 0xeb, 0xa4, 0x03, 0x50, 0x0c, 0x10,
1055                 0x50, 0xd8, 0xf7, 0x75, 0x52, 0x42, 0xe2, 0x94,
1056                 0x67, 0xf4, 0x60, 0xfb, 0x21, 0x9b, 0x7a, 0x05,
1057                 0x50, 0x7c, 0x1b, 0x4a, 0x8b, 0x29, 0xe1, 0xac,
1058                 0xd7, 0x99, 0xfd, 0x0d, 0x65, 0x92, 0xcd, 0x23,
1059                 0xa7, 0x35, 0x8e, 0x13, 0xf2, 0xe4, 0x10, 0x74,
1060                 0xc6, 0x4f, 0x19, 0xf7, 0x01, 0x0b, 0x46, 0xab,
1061                 0xef, 0x8d, 0x4a, 0x4a, 0xfa, 0xda, 0xf3, 0xfb,
1062                 0x40, 0x28, 0x88, 0xa2, 0x65, 0x98, 0x4d, 0x88,
1063                 0xc7, 0xbf, 0x00, 0xc8, 0xd0, 0x91, 0xcb, 0x89,
1064                 0x2f, 0xb0, 0x85, 0xfc, 0xa1, 0xc1, 0x9e, 0x83,
1065                 0x88, 0xad, 0x95, 0xc0, 0x31, 0xa0, 0xad, 0xa2,
1066                 0x42, 0xb5, 0xe7, 0x55, 0xd4, 0x93, 0x5a, 0x74,
1067                 0x4e, 0x41, 0xc3, 0xcf, 0x96, 0x83, 0x46, 0xa1,
1068                 0xb7, 0x5b, 0xb1, 0x34, 0x67, 0x4e, 0xb1, 0xd7,
1069                 0x40, 0x20, 0x72, 0xe9, 0xc8, 0x74, 0xb7, 0xde,
1070                 0x72, 0x29, 0x77, 0x4c, 0x74, 0x7e, 0xcc, 0x18,
1071                 0xa5, 0x8d, 0x79, 0x8c, 0xd6, 0x6e, 0xcb, 0xd9,
1072                 0xe1, 0x61, 0xe7, 0x36, 0xbc, 0x37, 0xea, 0xee,
1073                 0xd8, 0x3c, 0x5e, 0x7c, 0x47, 0x50, 0xd5, 0xec,
1074                 0x37, 0xc5, 0x63, 0xc3, 0xc9, 0x99, 0x23, 0x9f,
1075                 0x64, 0x39, 0xdf, 0x13, 0x96, 0x6d, 0xea, 0x08,
1076                 0x0c, 0x27, 0x2d, 0xfe, 0x0f, 0xc2, 0xa3, 0x97,
1077                 0x04, 0x12, 0x66, 0x0d, 0x94, 0xbf, 0xbe, 0x3e,
1078                 0xb9, 0xcf, 0x8e, 0xc1, 0x9d, 0xb1, 0x64, 0x17,
1079                 0x54, 0x92, 0x3f, 0x0a, 0x51, 0xc8, 0xf5, 0x82,
1080                 0x98, 0x73, 0x03, 0xc0, 0x5a, 0x51, 0x01, 0x67,
1081                 0xb4, 0x01, 0x04, 0x06, 0xbc, 0x37, 0xde, 0x96,
1082                 0x23, 0x3c, 0xce, 0x98, 0x3f, 0xd6, 0x51, 0x1b,
1083                 0x01, 0x83, 0x0a, 0x1c, 0xf9, 0xeb, 0x7e, 0x72,
1084                 0xa9, 0x51, 0x23, 0xc8, 0xd7, 0x2f, 0x12, 0xbc,
1085                 0x08, 0xac, 0x07, 0xe7, 0xa7, 0xe6, 0x46, 0xae,
1086                 0x54, 0xa3, 0xc2, 0xf2, 0x05, 0x2d, 0x06, 0x5e,
1087                 0xfc, 0xe2, 0xa2, 0x23, 0xac, 0x86, 0xf2, 0x54,
1088                 0x83, 0x4a, 0xb6, 0x48, 0x93, 0xa1, 0x78, 0xc2,
1089                 0x07, 0xec, 0x82, 0xf0, 0x74, 0xa9, 0x18, 0xe9,
1090                 0x53, 0x44, 0x49, 0xc2, 0x94, 0xf8, 0x94, 0x92,
1091                 0x08, 0x3f, 0xbf, 0xa6, 0xe5, 0xc6, 0x03, 0x8a,
1092                 0xc6, 0x90, 0x48, 0x6c, 0xee, 0xbd, 0x44, 0x92,
1093                 0x1f, 0x2a, 0xce, 0x1d, 0xb8, 0x31, 0xa2, 0x9d,
1094                 0x24, 0x93, 0xa8, 0x9f, 0x36, 0x00, 0x04, 0x7b,
1095                 0xcb, 0x93, 0x59, 0xa1, 0x53, 0xdb, 0x13, 0x7a,
1096                 0x54, 0xb1, 0x04, 0xdb, 0xce, 0x48, 0x4f, 0xe5,
1097                 0x2f, 0xcb, 0xdf, 0x8f, 0x50, 0x7c, 0xfc, 0x76,
1098                 0x80, 0xb4, 0xdc, 0x3b, 0xc8, 0x98, 0x95, 0xf5,
1099                 0x50, 0xba, 0x70, 0x5a, 0x97, 0xd5, 0xfc, 0x98,
1100                 0x4d, 0xf3, 0x61, 0x0f, 0xcf, 0xac, 0x49, 0x0a,
1101                 0xdb, 0xc1, 0x42, 0x8f, 0xb6, 0x29, 0xd5, 0x65,
1102                 0xef, 0x83, 0xf1, 0x30, 0x4b, 0x84, 0xd0, 0x69,
1103                 0xde, 0xd2, 0x99, 0xe5, 0xec, 0xd3, 0x90, 0x86,
1104                 0x39, 0x2a, 0x6e, 0xd5, 0x32, 0xe3, 0x0d, 0x2d,
1105                 0x01, 0x8b, 0x17, 0x55, 0x1d, 0x65, 0x57, 0xbf,
1106                 0xd8, 0x75, 0xa4, 0x85, 0xb6, 0x4e, 0x35, 0x14,
1107                 0x58, 0xe4, 0x89, 0xb8, 0x7a, 0x58, 0x86, 0x0c,
1108                 0xbd, 0x8b, 0x05, 0x7b, 0x63, 0xc0, 0x86, 0x80,
1109                 0x33, 0x46, 0xd4, 0x9b, 0xb6, 0x0a, 0xeb, 0x6c,
1110                 0xae, 0xd6, 0x57, 0x7a, 0xc7, 0x59, 0x33, 0xa0,
1111                 0xda, 0xa4, 0x12, 0xbf, 0x52, 0x22, 0x05, 0x8d,
1112                 0xeb, 0xee, 0xd5, 0xec, 0xea, 0x29, 0x9b, 0x76,
1113                 0x95, 0x50, 0x6d, 0x99, 0xe1, 0x45, 0x63, 0x09,
1114                 0x16, 0x5f, 0xb0, 0xf2, 0x5b, 0x08, 0x33, 0xdd,
1115                 0x8f, 0xb7, 0x60, 0x7a, 0x8e, 0xc6, 0xfc, 0xac,
1116                 0xa9, 0x56, 0x2c, 0xa9, 0x8b, 0x74, 0x33, 0xad,
1117                 0x2a, 0x7e, 0x96, 0xb6, 0xba, 0x22, 0x28, 0xcf,
1118                 0x4d, 0x96, 0xb7, 0xd1, 0xfa, 0x99, 0x4a, 0x61,
1119                 0xe6, 0x84, 0xd1, 0x94, 0xca, 0xf5, 0x86, 0xb0,
1120                 0xba, 0x34, 0x7a, 0x04, 0xcc, 0xd4, 0x81, 0xcd,
1121                 0xd9, 0x86, 0xb6, 0xe0, 0x5a, 0x6f, 0x9b, 0x99,
1122                 0xf0, 0xdf, 0x49, 0xae, 0x6d, 0xc2, 0x54, 0x67,
1123                 0xe0, 0xb4, 0x34, 0x2d, 0x1c, 0x46, 0xdf, 0x73,
1124                 0x3b, 0x45, 0x43, 0xe7, 0x1f, 0xa3, 0x36, 0x35,
1125                 0x25, 0x33, 0xd9, 0xc0, 0x54, 0x38, 0x6e, 0x6b,
1126                 0x80, 0xcf, 0x50, 0xa4, 0xb6, 0x21, 0x17, 0xfd,
1127                 0x9b, 0x5c, 0x36, 0xca, 0xcc, 0x73, 0x73, 0xad,
1128                 0xe0, 0x57, 0x77, 0x90, 0x0e, 0x7f, 0x0f, 0x87,
1129                 0x7f, 0xdb, 0x73, 0xbf, 0xda, 0xc2, 0xb3, 0x05,
1130                 0x22, 0x06, 0xf5, 0xa3, 0xfc, 0x1e, 0x8f, 0xda,
1131                 0xcf, 0x49, 0xd6, 0xb3, 0x66, 0x2c, 0xb5, 0x00,
1132                 0xaf, 0x85, 0x6e, 0xb8, 0x5b, 0x8c, 0xa1, 0xa4,
1133                 0x21, 0xce, 0x40, 0xf3, 0x98, 0xac, 0xec, 0x88,
1134                 0x62, 0x43, 0x2a, 0xac, 0xca, 0xcf, 0xb9, 0x30,
1135                 0xeb, 0xfc, 0xef, 0xf0, 0x6e, 0x64, 0x6d, 0xe7,
1136                 0x54, 0x88, 0x6b, 0x22, 0x29, 0xbe, 0xa5, 0x8c,
1137                 0x31, 0x23, 0x3b, 0x4a, 0x80, 0x37, 0xe6, 0xd0,
1138                 0x05, 0xfc, 0x10, 0x0e, 0xdd, 0xbb, 0x00, 0xc5,
1139                 0x07, 0x20, 0x59, 0xd3, 0x41, 0x17, 0x86, 0x46,
1140                 0xab, 0x68, 0xf6, 0x48, 0x3c, 0xea, 0x5a, 0x06,
1141                 0x30, 0x21, 0x19, 0xed, 0x74, 0xbe, 0x0b, 0x97,
1142                 0xee, 0x91, 0x35, 0x94, 0x1f, 0xcb, 0x68, 0x7f,
1143                 0xe4, 0x48, 0xb0, 0x16, 0xfb, 0xf0, 0x74, 0xdb,
1144                 0x06, 0x59, 0x2e, 0x5a, 0x9c, 0xce, 0x8f, 0x7d,
1145                 0xba, 0x48, 0xd5, 0x3f, 0x5c, 0xb0, 0xc2, 0x33,
1146                 0x48, 0x60, 0x17, 0x08, 0x85, 0xba, 0xff, 0xb9,
1147                 0x34, 0x0a, 0x3d, 0x8f, 0x21, 0x13, 0x12, 0x1b
1148 };
1149
1150 static const uint8_t AES_CBC_ciphertext_1536B[] = {
1151                 0x89, 0x93, 0x05, 0x99, 0xa9, 0xed, 0xea, 0x62,
1152                 0xc9, 0xda, 0x51, 0x15, 0xce, 0x42, 0x91, 0xc3,
1153                 0x80, 0xc8, 0x03, 0x88, 0xc2, 0x63, 0xda, 0x53,
1154                 0x1a, 0xf3, 0xeb, 0xd5, 0xba, 0x6f, 0x23, 0xb2,
1155                 0xed, 0x8f, 0x89, 0xb1, 0xb3, 0xca, 0x90, 0x7a,
1156                 0xdd, 0x3f, 0xf6, 0xca, 0x86, 0x58, 0x54, 0xbc,
1157                 0xab, 0x0f, 0xf4, 0xab, 0x6d, 0x5d, 0x42, 0xd0,
1158                 0x17, 0x49, 0x17, 0xd1, 0x93, 0xea, 0xe8, 0x22,
1159                 0xc1, 0x34, 0x9f, 0x3a, 0x3b, 0xaa, 0xe9, 0x1b,
1160                 0x93, 0xff, 0x6b, 0x68, 0xba, 0xe6, 0xd2, 0x39,
1161                 0x3d, 0x55, 0x34, 0x8f, 0x98, 0x86, 0xb4, 0xd8,
1162                 0x7c, 0x0d, 0x3e, 0x01, 0x63, 0x04, 0x01, 0xff,
1163                 0x16, 0x0f, 0x51, 0x5f, 0x73, 0x53, 0xf0, 0x3a,
1164                 0x38, 0xb4, 0x4d, 0x8d, 0xaf, 0xa3, 0xca, 0x2f,
1165                 0x6f, 0xdf, 0xc0, 0x41, 0x6c, 0x48, 0x60, 0x1a,
1166                 0xe4, 0xe7, 0x8a, 0x65, 0x6f, 0x8d, 0xd7, 0xe1,
1167                 0x10, 0xab, 0x78, 0x5b, 0xb9, 0x69, 0x1f, 0xe0,
1168                 0x5c, 0xf1, 0x19, 0x12, 0x21, 0xc7, 0x51, 0xbc,
1169                 0x61, 0x5f, 0xc0, 0x36, 0x17, 0xc0, 0x28, 0xd9,
1170                 0x51, 0xcb, 0x43, 0xd9, 0xfa, 0xd1, 0xad, 0x79,
1171                 0x69, 0x86, 0x49, 0xc5, 0xe5, 0x69, 0x27, 0xce,
1172                 0x22, 0xd0, 0xe1, 0x6a, 0xf9, 0x02, 0xca, 0x6c,
1173                 0x34, 0xc7, 0xb8, 0x02, 0xc1, 0x38, 0x7f, 0xd5,
1174                 0x15, 0xf5, 0xd6, 0xeb, 0xf9, 0x30, 0x40, 0x43,
1175                 0xea, 0x87, 0xde, 0x35, 0xf6, 0x83, 0x59, 0x09,
1176                 0x68, 0x62, 0x00, 0x87, 0xb8, 0xe7, 0xca, 0x05,
1177                 0x0f, 0xac, 0x42, 0x58, 0x45, 0xaa, 0xc9, 0x9b,
1178                 0xfd, 0x2a, 0xda, 0x65, 0x33, 0x93, 0x9d, 0xc6,
1179                 0x93, 0x8d, 0xe2, 0xc5, 0x71, 0xc1, 0x5c, 0x13,
1180                 0xde, 0x7b, 0xd4, 0xb9, 0x4c, 0x35, 0x61, 0x85,
1181                 0x90, 0x78, 0xf7, 0x81, 0x98, 0x45, 0x99, 0x24,
1182                 0x58, 0x73, 0x28, 0xf8, 0x31, 0xab, 0x54, 0x2e,
1183                 0xc0, 0x38, 0x77, 0x25, 0x5c, 0x06, 0x9c, 0xc3,
1184                 0x69, 0x21, 0x92, 0x76, 0xe1, 0x16, 0xdc, 0xa9,
1185                 0xee, 0xb6, 0x80, 0x66, 0x43, 0x11, 0x24, 0xb3,
1186                 0x07, 0x17, 0x89, 0x0f, 0xcb, 0xe0, 0x60, 0xa8,
1187                 0x9d, 0x06, 0x4b, 0x6e, 0x72, 0xb7, 0xbc, 0x4f,
1188                 0xb8, 0xc0, 0x80, 0xa2, 0xfb, 0x46, 0x5b, 0x8f,
1189                 0x11, 0x01, 0x92, 0x9d, 0x37, 0x09, 0x98, 0xc8,
1190                 0x0a, 0x46, 0xae, 0x12, 0xac, 0x61, 0x3f, 0xe7,
1191                 0x41, 0x1a, 0xaa, 0x2e, 0xdc, 0xd7, 0x2a, 0x47,
1192                 0xee, 0xdf, 0x08, 0xd1, 0xff, 0xea, 0x13, 0xc6,
1193                 0x05, 0xdb, 0x29, 0xcc, 0x03, 0xba, 0x7b, 0x6d,
1194                 0x40, 0xc1, 0xc9, 0x76, 0x75, 0x03, 0x7a, 0x71,
1195                 0xc9, 0x5f, 0xd9, 0xe0, 0x61, 0x69, 0x36, 0x8f,
1196                 0xb2, 0xbc, 0x28, 0xf3, 0x90, 0x71, 0xda, 0x5f,
1197                 0x08, 0xd5, 0x0d, 0xc1, 0xe6, 0xbd, 0x2b, 0xc6,
1198                 0x6c, 0x42, 0xfd, 0xbf, 0x10, 0xe8, 0x5f, 0x87,
1199                 0x3d, 0x21, 0x42, 0x85, 0x01, 0x0a, 0xbf, 0x8e,
1200                 0x49, 0xd3, 0x9c, 0x89, 0x3b, 0xea, 0xe1, 0xbf,
1201                 0xe9, 0x9b, 0x5e, 0x0e, 0xb8, 0xeb, 0xcd, 0x3a,
1202                 0xf6, 0x29, 0x41, 0x35, 0xdd, 0x9b, 0x13, 0x24,
1203                 0xe0, 0x1d, 0x8a, 0xcb, 0x20, 0xf8, 0x41, 0x51,
1204                 0x3e, 0x23, 0x8c, 0x67, 0x98, 0x39, 0x53, 0x77,
1205                 0x2a, 0x68, 0xf4, 0x3c, 0x7e, 0xd6, 0xc4, 0x6e,
1206                 0xf1, 0x53, 0xe9, 0xd8, 0x5c, 0xc1, 0xa9, 0x38,
1207                 0x6f, 0x5e, 0xe4, 0xd4, 0x29, 0x1c, 0x6c, 0xee,
1208                 0x2f, 0xea, 0xde, 0x61, 0x71, 0x5a, 0xea, 0xce,
1209                 0x23, 0x6e, 0x1b, 0x16, 0x43, 0xb7, 0xc0, 0xe3,
1210                 0x87, 0xa1, 0x95, 0x1e, 0x97, 0x4d, 0xea, 0xa6,
1211                 0xf7, 0x25, 0xac, 0x82, 0x2a, 0xd3, 0xa6, 0x99,
1212                 0x75, 0xdd, 0xc1, 0x55, 0x32, 0x6b, 0xea, 0x33,
1213                 0x88, 0xce, 0x06, 0xac, 0x15, 0x39, 0x19, 0xa3,
1214                 0x59, 0xaf, 0x7a, 0x1f, 0xd9, 0x72, 0x5e, 0xf7,
1215                 0x4c, 0xf3, 0x5d, 0x6b, 0xf2, 0x16, 0x92, 0xa8,
1216                 0x9e, 0x3d, 0xd4, 0x4c, 0x72, 0x55, 0x4e, 0x4a,
1217                 0xf7, 0x8b, 0x2f, 0x67, 0x5a, 0x90, 0xb7, 0xcf,
1218                 0x16, 0xd3, 0x7b, 0x5a, 0x9a, 0xc8, 0x9f, 0xbf,
1219                 0x01, 0x76, 0x3b, 0x86, 0x2c, 0x2a, 0x78, 0x10,
1220                 0x70, 0x05, 0x38, 0xf9, 0xdd, 0x2a, 0x1d, 0x00,
1221                 0x25, 0xb7, 0x10, 0xac, 0x3b, 0x3c, 0x4d, 0x3c,
1222                 0x01, 0x68, 0x3c, 0x5a, 0x29, 0xc2, 0xa0, 0x1b,
1223                 0x95, 0x67, 0xf9, 0x0a, 0x60, 0xb7, 0x11, 0x9c,
1224                 0x40, 0x45, 0xd7, 0xb0, 0xda, 0x49, 0x87, 0xcd,
1225                 0xb0, 0x9b, 0x61, 0x8c, 0xf4, 0x0d, 0x94, 0x1d,
1226                 0x79, 0x66, 0x13, 0x0b, 0xc6, 0x6b, 0x19, 0xee,
1227                 0xa0, 0x6b, 0x64, 0x7d, 0xc4, 0xff, 0x98, 0x72,
1228                 0x60, 0xab, 0x7f, 0x0f, 0x4d, 0x5d, 0x6b, 0xc3,
1229                 0xba, 0x5e, 0x0d, 0x04, 0xd9, 0x59, 0x17, 0xd0,
1230                 0x64, 0xbe, 0xfb, 0x58, 0xfc, 0xed, 0x18, 0xf6,
1231                 0xac, 0x19, 0xa4, 0xfd, 0x16, 0x59, 0x80, 0x58,
1232                 0xb8, 0x0f, 0x79, 0x24, 0x60, 0x18, 0x62, 0xa9,
1233                 0xa3, 0xa0, 0xe8, 0x81, 0xd6, 0xec, 0x5b, 0xfe,
1234                 0x5b, 0xb8, 0xa4, 0x00, 0xa9, 0xd0, 0x90, 0x17,
1235                 0xe5, 0x50, 0x3d, 0x2b, 0x12, 0x6e, 0x2a, 0x13,
1236                 0x65, 0x7c, 0xdf, 0xdf, 0xa7, 0xdd, 0x9f, 0x78,
1237                 0x5f, 0x8f, 0x4e, 0x90, 0xa6, 0x10, 0xe4, 0x7b,
1238                 0x68, 0x6b, 0xfd, 0xa9, 0x6d, 0x47, 0xfa, 0xec,
1239                 0x42, 0x35, 0x07, 0x12, 0x3e, 0x78, 0x23, 0x15,
1240                 0xff, 0xe2, 0x65, 0xc7, 0x47, 0x89, 0x2f, 0x97,
1241                 0x7c, 0xd7, 0x6b, 0x69, 0x35, 0x79, 0x6f, 0x85,
1242                 0xb4, 0xa9, 0x75, 0x04, 0x32, 0x9a, 0xfe, 0xf0,
1243                 0xce, 0xe3, 0xf1, 0xab, 0x15, 0x47, 0xe4, 0x9c,
1244                 0xc1, 0x48, 0x32, 0x3c, 0xbe, 0x44, 0x72, 0xc9,
1245                 0xaa, 0x50, 0x37, 0xa6, 0xbe, 0x41, 0xcf, 0xe8,
1246                 0x17, 0x4e, 0x37, 0xbe, 0xf1, 0x34, 0x2c, 0xd9,
1247                 0x60, 0x48, 0x09, 0xa5, 0x26, 0x00, 0x31, 0x77,
1248                 0x4e, 0xac, 0x7c, 0x89, 0x75, 0xe3, 0xde, 0x26,
1249                 0x4c, 0x32, 0x54, 0x27, 0x8e, 0x92, 0x26, 0x42,
1250                 0x85, 0x76, 0x01, 0x76, 0x62, 0x4c, 0x29, 0xe9,
1251                 0x38, 0x05, 0x51, 0x54, 0x97, 0xa3, 0x03, 0x59,
1252                 0x5e, 0xec, 0x0c, 0xe4, 0x96, 0xb7, 0x15, 0xa8,
1253                 0x41, 0x06, 0x2b, 0x78, 0x95, 0x24, 0xf6, 0x32,
1254                 0xc5, 0xec, 0xd7, 0x89, 0x28, 0x1e, 0xec, 0xb1,
1255                 0xc7, 0x21, 0x0c, 0xd3, 0x80, 0x7c, 0x5a, 0xe6,
1256                 0xb1, 0x3a, 0x52, 0x33, 0x84, 0x4e, 0x32, 0x6e,
1257                 0x7a, 0xf6, 0x43, 0x15, 0x5b, 0xa6, 0xba, 0xeb,
1258                 0xa8, 0xe4, 0xff, 0x4f, 0xbd, 0xbd, 0xa8, 0x5e,
1259                 0xbe, 0x27, 0xaf, 0xc5, 0xf7, 0x9e, 0xdf, 0x48,
1260                 0x22, 0xca, 0x6a, 0x0b, 0x3c, 0xd7, 0xe0, 0xdc,
1261                 0xf3, 0x71, 0x08, 0xdc, 0x28, 0x13, 0x08, 0xf2,
1262                 0x08, 0x1d, 0x9d, 0x7b, 0xd9, 0xde, 0x6f, 0xe6,
1263                 0xe8, 0x88, 0x18, 0xc2, 0xcd, 0x93, 0xc5, 0x38,
1264                 0x21, 0x68, 0x4c, 0x9a, 0xfb, 0xb6, 0x18, 0x16,
1265                 0x73, 0x2c, 0x1d, 0x6f, 0x95, 0xfb, 0x65, 0x4f,
1266                 0x7c, 0xec, 0x8d, 0x6c, 0xa8, 0xc0, 0x55, 0x28,
1267                 0xc6, 0xc3, 0xea, 0xeb, 0x05, 0xf5, 0x65, 0xeb,
1268                 0x53, 0xe1, 0x54, 0xef, 0xb8, 0x64, 0x98, 0x2d,
1269                 0x98, 0x9e, 0xc8, 0xfe, 0xa2, 0x07, 0x30, 0xf7,
1270                 0xf7, 0xae, 0xdb, 0x32, 0xf8, 0x71, 0x9d, 0x06,
1271                 0xdf, 0x9b, 0xda, 0x61, 0x7d, 0xdb, 0xae, 0x06,
1272                 0x24, 0x63, 0x74, 0xb6, 0xf3, 0x1b, 0x66, 0x09,
1273                 0x60, 0xff, 0x2b, 0x29, 0xf5, 0xa9, 0x9d, 0x61,
1274                 0x5d, 0x55, 0x10, 0x82, 0x21, 0xbb, 0x64, 0x0d,
1275                 0xef, 0x5c, 0xe3, 0x30, 0x1b, 0x60, 0x1e, 0x5b,
1276                 0xfe, 0x6c, 0xf5, 0x15, 0xa3, 0x86, 0x27, 0x58,
1277                 0x46, 0x00, 0x20, 0xcb, 0x86, 0x9a, 0x52, 0x29,
1278                 0x20, 0x68, 0x4d, 0x67, 0x88, 0x70, 0xc2, 0x31,
1279                 0xd8, 0xbb, 0xa5, 0xa7, 0x88, 0x7f, 0x66, 0xbc,
1280                 0xaa, 0x0f, 0xe1, 0x78, 0x7b, 0x97, 0x3c, 0xb7,
1281                 0xd7, 0xd8, 0x04, 0xe0, 0x09, 0x60, 0xc8, 0xd0,
1282                 0x9e, 0xe5, 0x6b, 0x31, 0x7f, 0x88, 0xfe, 0xc3,
1283                 0xfd, 0x89, 0xec, 0x76, 0x4b, 0xb3, 0xa7, 0x37,
1284                 0x03, 0xb7, 0xc6, 0x10, 0x7c, 0x9d, 0x0c, 0x75,
1285                 0xd3, 0x08, 0x14, 0x94, 0x03, 0x42, 0x25, 0x26,
1286                 0x85, 0xf7, 0xf0, 0x90, 0x06, 0x3e, 0x6f, 0x60,
1287                 0x52, 0x55, 0xd5, 0x0f, 0x79, 0x64, 0x69, 0x69,
1288                 0x46, 0xf9, 0x7f, 0x7f, 0x03, 0xf1, 0x1f, 0xdb,
1289                 0x39, 0x05, 0xba, 0x4a, 0x8f, 0x17, 0xe7, 0xba,
1290                 0xe2, 0x07, 0x7c, 0x1d, 0x9e, 0xbc, 0x94, 0xc0,
1291                 0x61, 0x59, 0x8e, 0x72, 0xaf, 0xfc, 0x99, 0xe4,
1292                 0xd5, 0xa8, 0xee, 0x0a, 0x48, 0x2d, 0x82, 0x8b,
1293                 0x34, 0x54, 0x8a, 0xce, 0xc7, 0xfa, 0xdd, 0xba,
1294                 0x54, 0xdf, 0xb3, 0x30, 0x33, 0x73, 0x2e, 0xd5,
1295                 0x52, 0xab, 0x49, 0x91, 0x4e, 0x0a, 0xd6, 0x2f,
1296                 0x67, 0xe4, 0xdd, 0x64, 0x48, 0x16, 0xd9, 0x85,
1297                 0xaa, 0x52, 0xa5, 0x0b, 0xd3, 0xb4, 0x2d, 0x77,
1298                 0x5e, 0x52, 0x77, 0x17, 0xcf, 0xbe, 0x88, 0x04,
1299                 0x01, 0x52, 0xe2, 0xf1, 0x46, 0xe2, 0x91, 0x30,
1300                 0x65, 0xcf, 0xc0, 0x65, 0x45, 0xc3, 0x7e, 0xf4,
1301                 0x2e, 0xb5, 0xaf, 0x6f, 0xab, 0x1a, 0xfa, 0x70,
1302                 0x35, 0xb8, 0x4f, 0x2d, 0x78, 0x90, 0x33, 0xb5,
1303                 0x9a, 0x67, 0xdb, 0x2f, 0x28, 0x32, 0xb6, 0x54,
1304                 0xab, 0x4c, 0x6b, 0x85, 0xed, 0x6c, 0x3e, 0x05,
1305                 0x2a, 0xc7, 0x32, 0xe8, 0xf5, 0xa3, 0x7b, 0x4e,
1306                 0x7b, 0x58, 0x24, 0x73, 0xf7, 0xfd, 0xc7, 0xc8,
1307                 0x6c, 0x71, 0x68, 0xb1, 0xf6, 0xc5, 0x9e, 0x1e,
1308                 0xe3, 0x5c, 0x25, 0xc0, 0x5b, 0x3e, 0x59, 0xa1,
1309                 0x18, 0x5a, 0xe8, 0xb5, 0xd1, 0x44, 0x13, 0xa3,
1310                 0xe6, 0x05, 0x76, 0xd2, 0x8d, 0x6e, 0x54, 0x68,
1311                 0x0c, 0xa4, 0x7b, 0x8b, 0xd3, 0x8c, 0x42, 0x13,
1312                 0x87, 0xda, 0xdf, 0x8f, 0xa5, 0x83, 0x7a, 0x42,
1313                 0x99, 0xb7, 0xeb, 0xe2, 0x79, 0xe0, 0xdb, 0xda,
1314                 0x33, 0xa8, 0x50, 0x3a, 0xd7, 0xe7, 0xd3, 0x61,
1315                 0x18, 0xb8, 0xaa, 0x2d, 0xc8, 0xd8, 0x2c, 0x28,
1316                 0xe5, 0x97, 0x0a, 0x7c, 0x6c, 0x7f, 0x09, 0xd7,
1317                 0x88, 0x80, 0xac, 0x12, 0xed, 0xf8, 0xc6, 0xb5,
1318                 0x2d, 0xd6, 0x63, 0x9b, 0x98, 0x35, 0x26, 0xde,
1319                 0xf6, 0x31, 0xee, 0x7e, 0xa0, 0xfb, 0x16, 0x98,
1320                 0xb1, 0x96, 0x1d, 0xee, 0xe3, 0x2f, 0xfb, 0x41,
1321                 0xdd, 0xea, 0x10, 0x1e, 0x03, 0x89, 0x18, 0xd2,
1322                 0x47, 0x0c, 0xa0, 0x57, 0xda, 0x76, 0x3a, 0x37,
1323                 0x2c, 0xe4, 0xf9, 0x77, 0xc8, 0x43, 0x5f, 0xcb,
1324                 0xd6, 0x85, 0xf7, 0x22, 0xe4, 0x32, 0x25, 0xa8,
1325                 0xdc, 0x21, 0xc0, 0xf5, 0x95, 0xb2, 0xf8, 0x83,
1326                 0xf0, 0x65, 0x61, 0x15, 0x48, 0x94, 0xb7, 0x03,
1327                 0x7f, 0x66, 0xa1, 0x39, 0x1f, 0xdd, 0xce, 0x96,
1328                 0xfe, 0x58, 0x81, 0x3d, 0x41, 0x11, 0x87, 0x13,
1329                 0x26, 0x1b, 0x6d, 0xf3, 0xca, 0x2e, 0x2c, 0x76,
1330                 0xd3, 0x2f, 0x6d, 0x49, 0x70, 0x53, 0x05, 0x96,
1331                 0xcc, 0x30, 0x2b, 0x83, 0xf2, 0xc6, 0xb2, 0x4b,
1332                 0x22, 0x13, 0x95, 0x42, 0xeb, 0x56, 0x4d, 0x22,
1333                 0xe6, 0x43, 0x6f, 0xba, 0xe7, 0x3b, 0xe5, 0x59,
1334                 0xce, 0x57, 0x88, 0x85, 0xb6, 0xbf, 0x15, 0x37,
1335                 0xb3, 0x7a, 0x7e, 0xc4, 0xbc, 0x99, 0xfc, 0xe4,
1336                 0x89, 0x00, 0x68, 0x39, 0xbc, 0x5a, 0xba, 0xab,
1337                 0x52, 0xab, 0xe6, 0x81, 0xfd, 0x93, 0x62, 0xe9,
1338                 0xb7, 0x12, 0xd1, 0x18, 0x1a, 0xb9, 0x55, 0x4a,
1339                 0x0f, 0xae, 0x35, 0x11, 0x04, 0x27, 0xf3, 0x42,
1340                 0x4e, 0xca, 0xdf, 0x9f, 0x12, 0x62, 0xea, 0x03,
1341                 0xc0, 0xa9, 0x22, 0x7b, 0x6c, 0x6c, 0xe3, 0xdf,
1342                 0x16, 0xad, 0x03, 0xc9, 0xfe, 0xa4, 0xdd, 0x4f
1343 };
1344
1345 static const uint8_t AES_CBC_ciphertext_1792B[] = {
1346                 0x59, 0xcc, 0xfe, 0x8f, 0xb4, 0x9d, 0x0e, 0xd1,
1347                 0x85, 0xfc, 0x9b, 0x43, 0xc1, 0xb7, 0x54, 0x67,
1348                 0x01, 0xef, 0xb8, 0x71, 0x36, 0xdb, 0x50, 0x48,
1349                 0x7a, 0xea, 0xcf, 0xce, 0xba, 0x30, 0x10, 0x2e,
1350                 0x96, 0x2b, 0xfd, 0xcf, 0x00, 0xe3, 0x1f, 0xac,
1351                 0x66, 0x14, 0x30, 0x86, 0x49, 0xdb, 0x01, 0x8b,
1352                 0x07, 0xdd, 0x00, 0x9d, 0x0d, 0x5c, 0x19, 0x11,
1353                 0xe8, 0x44, 0x2b, 0x25, 0x70, 0xed, 0x7c, 0x33,
1354                 0x0d, 0xe3, 0x34, 0x93, 0x63, 0xad, 0x26, 0xb1,
1355                 0x11, 0x91, 0x34, 0x2e, 0x1d, 0x50, 0xaa, 0xd4,
1356                 0xef, 0x3a, 0x6d, 0xd7, 0x33, 0x20, 0x0d, 0x3f,
1357                 0x9b, 0xdd, 0xc3, 0xa5, 0xc5, 0xf1, 0x99, 0xdc,
1358                 0xea, 0x52, 0xda, 0x55, 0xea, 0xa2, 0x7a, 0xc5,
1359                 0x78, 0x44, 0x4a, 0x02, 0x33, 0x19, 0x62, 0x37,
1360                 0xf8, 0x8b, 0xd1, 0x0c, 0x21, 0xdf, 0x40, 0x19,
1361                 0x81, 0xea, 0xfb, 0x1c, 0xa7, 0xcc, 0x60, 0xfe,
1362                 0x63, 0x25, 0x8f, 0xf3, 0x73, 0x0f, 0x45, 0xe6,
1363                 0x6a, 0x18, 0xbf, 0xbe, 0xad, 0x92, 0x2a, 0x1e,
1364                 0x15, 0x65, 0x6f, 0xef, 0x92, 0xcd, 0x0e, 0x19,
1365                 0x3d, 0x42, 0xa8, 0xfc, 0x0d, 0x32, 0x58, 0xe0,
1366                 0x56, 0x9f, 0xd6, 0x9b, 0x8b, 0xec, 0xe0, 0x45,
1367                 0x4d, 0x7e, 0x73, 0x87, 0xff, 0x74, 0x92, 0x59,
1368                 0x60, 0x13, 0x93, 0xda, 0xec, 0xbf, 0xfa, 0x20,
1369                 0xb6, 0xe7, 0xdf, 0xc7, 0x10, 0xf5, 0x79, 0xb4,
1370                 0xd7, 0xac, 0xaf, 0x2b, 0x37, 0x52, 0x30, 0x1d,
1371                 0xbe, 0x0f, 0x60, 0x77, 0x3d, 0x03, 0x63, 0xa9,
1372                 0xae, 0xb1, 0xf3, 0xca, 0xca, 0xb4, 0x21, 0xd7,
1373                 0x6f, 0x2e, 0x5e, 0x9b, 0x68, 0x53, 0x80, 0xab,
1374                 0x30, 0x23, 0x0a, 0x72, 0x6b, 0xb1, 0xd8, 0x25,
1375                 0x5d, 0x3a, 0x62, 0x9b, 0x4f, 0x59, 0x3b, 0x79,
1376                 0xa8, 0x9e, 0x08, 0x6d, 0x37, 0xb0, 0xfc, 0x42,
1377                 0x51, 0x25, 0x86, 0xbd, 0x54, 0x5a, 0x95, 0x20,
1378                 0x6c, 0xac, 0xb9, 0x30, 0x1c, 0x03, 0xc9, 0x49,
1379                 0x38, 0x55, 0x31, 0x49, 0xed, 0xa9, 0x0e, 0xc3,
1380                 0x65, 0xb4, 0x68, 0x6b, 0x07, 0x4c, 0x0a, 0xf9,
1381                 0x21, 0x69, 0x7c, 0x9f, 0x28, 0x80, 0xe9, 0x49,
1382                 0x22, 0x7c, 0xec, 0x97, 0xf7, 0x70, 0xb4, 0xb8,
1383                 0x25, 0xe7, 0x80, 0x2c, 0x43, 0x24, 0x8a, 0x2e,
1384                 0xac, 0xa2, 0x84, 0x20, 0xe7, 0xf4, 0x6b, 0x86,
1385                 0x37, 0x05, 0xc7, 0x59, 0x04, 0x49, 0x2a, 0x99,
1386                 0x80, 0x46, 0x32, 0x19, 0xe6, 0x30, 0xce, 0xc0,
1387                 0xef, 0x6e, 0xec, 0xe5, 0x2f, 0x24, 0xc1, 0x78,
1388                 0x45, 0x02, 0xd3, 0x64, 0x99, 0xf5, 0xc7, 0xbc,
1389                 0x8f, 0x8c, 0x75, 0xb1, 0x0a, 0xc8, 0xc3, 0xbd,
1390                 0x5e, 0x7e, 0xbd, 0x0e, 0xdf, 0x4b, 0x96, 0x6a,
1391                 0xfd, 0x03, 0xdb, 0xd1, 0x31, 0x1e, 0x27, 0xf9,
1392                 0xe5, 0x83, 0x9a, 0xfc, 0x13, 0x4c, 0xd3, 0x04,
1393                 0xdb, 0xdb, 0x3f, 0x35, 0x93, 0x4e, 0x14, 0x6b,
1394                 0x00, 0x5c, 0xb6, 0x11, 0x50, 0xee, 0x61, 0x5c,
1395                 0x10, 0x5c, 0xd0, 0x90, 0x02, 0x2e, 0x12, 0xe0,
1396                 0x50, 0x44, 0xad, 0x75, 0xcd, 0x94, 0xcf, 0x92,
1397                 0xcb, 0xe3, 0xe8, 0x77, 0x4b, 0xd7, 0x1a, 0x7c,
1398                 0xdd, 0x6b, 0x49, 0x21, 0x7c, 0xe8, 0x2c, 0x25,
1399                 0x49, 0x86, 0x1e, 0x54, 0xae, 0xfc, 0x0e, 0x80,
1400                 0xb1, 0xd5, 0xa5, 0x23, 0xcf, 0xcc, 0x0e, 0x11,
1401                 0xe2, 0x7c, 0x3c, 0x25, 0x78, 0x64, 0x03, 0xa1,
1402                 0xdd, 0x9f, 0x74, 0x12, 0x7b, 0x21, 0xb5, 0x73,
1403                 0x15, 0x3c, 0xed, 0xad, 0x07, 0x62, 0x21, 0x79,
1404                 0xd4, 0x2f, 0x0d, 0x72, 0xe9, 0x7c, 0x6b, 0x96,
1405                 0x6e, 0xe5, 0x36, 0x4a, 0xd2, 0x38, 0xe1, 0xff,
1406                 0x6e, 0x26, 0xa4, 0xac, 0x83, 0x07, 0xe6, 0x67,
1407                 0x74, 0x6c, 0xec, 0x8b, 0x4b, 0x79, 0x33, 0x50,
1408                 0x2f, 0x8f, 0xa0, 0x8f, 0xfa, 0x38, 0x6a, 0xa2,
1409                 0x3a, 0x42, 0x85, 0x15, 0x90, 0xd0, 0xb3, 0x0d,
1410                 0x8a, 0xe4, 0x60, 0x03, 0xef, 0xf9, 0x65, 0x8a,
1411                 0x4e, 0x50, 0x8c, 0x65, 0xba, 0x61, 0x16, 0xc3,
1412                 0x93, 0xb7, 0x75, 0x21, 0x98, 0x25, 0x60, 0x6e,
1413                 0x3d, 0x68, 0xba, 0x7c, 0xe4, 0xf3, 0xd9, 0x9b,
1414                 0xfb, 0x7a, 0xed, 0x1f, 0xb3, 0x4b, 0x88, 0x74,
1415                 0x2c, 0xb8, 0x8c, 0x22, 0x95, 0xce, 0x90, 0xf1,
1416                 0xdb, 0x80, 0xa6, 0x39, 0xae, 0x82, 0xa1, 0xef,
1417                 0x75, 0xec, 0xfe, 0xf1, 0xe8, 0x04, 0xfd, 0x99,
1418                 0x1b, 0x5f, 0x45, 0x87, 0x4f, 0xfa, 0xa2, 0x3e,
1419                 0x3e, 0xb5, 0x01, 0x4b, 0x46, 0xeb, 0x13, 0x9a,
1420                 0xe4, 0x7d, 0x03, 0x87, 0xb1, 0x59, 0x91, 0x8e,
1421                 0x37, 0xd3, 0x16, 0xce, 0xef, 0x4b, 0xe9, 0x46,
1422                 0x8d, 0x2a, 0x50, 0x2f, 0x41, 0xd3, 0x7b, 0xcf,
1423                 0xf0, 0xb7, 0x8b, 0x65, 0x0f, 0xa3, 0x27, 0x10,
1424                 0xe9, 0xa9, 0xe9, 0x2c, 0xbe, 0xbb, 0x82, 0xe3,
1425                 0x7b, 0x0b, 0x81, 0x3e, 0xa4, 0x6a, 0x4f, 0x3b,
1426                 0xd5, 0x61, 0xf8, 0x47, 0x04, 0x99, 0x5b, 0xff,
1427                 0xf3, 0x14, 0x6e, 0x57, 0x5b, 0xbf, 0x1b, 0xb4,
1428                 0x3f, 0xf9, 0x31, 0xf6, 0x95, 0xd5, 0x10, 0xa9,
1429                 0x72, 0x28, 0x23, 0xa9, 0x6a, 0xa2, 0xcf, 0x7d,
1430                 0xe3, 0x18, 0x95, 0xda, 0xbc, 0x6f, 0xe9, 0xd8,
1431                 0xef, 0x49, 0x3f, 0xd3, 0xef, 0x1f, 0xe1, 0x50,
1432                 0xe8, 0x8a, 0xc0, 0xce, 0xcc, 0xb7, 0x5e, 0x0e,
1433                 0x8b, 0x95, 0x80, 0xfd, 0x58, 0x2a, 0x9b, 0xc8,
1434                 0xb4, 0x17, 0x04, 0x46, 0x74, 0xd4, 0x68, 0x91,
1435                 0x33, 0xc8, 0x31, 0x15, 0x84, 0x16, 0x35, 0x03,
1436                 0x64, 0x6d, 0xa9, 0x4e, 0x20, 0xeb, 0xa9, 0x3f,
1437                 0x21, 0x5e, 0x9b, 0x09, 0xc3, 0x45, 0xf8, 0x7c,
1438                 0x59, 0x62, 0x29, 0x9a, 0x5c, 0xcf, 0xb4, 0x27,
1439                 0x5e, 0x13, 0xea, 0xb3, 0xef, 0xd9, 0x01, 0x2a,
1440                 0x65, 0x5f, 0x14, 0xf4, 0xbf, 0x28, 0x89, 0x3d,
1441                 0xdd, 0x9d, 0x52, 0xbd, 0x9e, 0x5b, 0x3b, 0xd2,
1442                 0xc2, 0x81, 0x35, 0xb6, 0xac, 0xdd, 0x27, 0xc3,
1443                 0x7b, 0x01, 0x5a, 0x6d, 0x4c, 0x5e, 0x2c, 0x30,
1444                 0xcb, 0x3a, 0xfa, 0xc1, 0xd7, 0x31, 0x67, 0x3e,
1445                 0x08, 0x6a, 0xe8, 0x8c, 0x75, 0xac, 0x1a, 0x6a,
1446                 0x52, 0xf7, 0x51, 0xcd, 0x85, 0x3f, 0x3c, 0xa7,
1447                 0xea, 0xbc, 0xd7, 0x18, 0x9e, 0x27, 0x73, 0xe6,
1448                 0x2b, 0x58, 0xb6, 0xd2, 0x29, 0x68, 0xd5, 0x8f,
1449                 0x00, 0x4d, 0x55, 0xf6, 0x61, 0x5a, 0xcc, 0x51,
1450                 0xa6, 0x5e, 0x85, 0xcb, 0x0b, 0xfd, 0x06, 0xca,
1451                 0xf5, 0xbf, 0x0d, 0x13, 0x74, 0x78, 0x6d, 0x9e,
1452                 0x20, 0x11, 0x84, 0x3e, 0x78, 0x17, 0x04, 0x4f,
1453                 0x64, 0x2c, 0x3b, 0x3e, 0x93, 0x7b, 0x58, 0x33,
1454                 0x07, 0x52, 0xf7, 0x60, 0x6a, 0xa8, 0x3b, 0x19,
1455                 0x27, 0x7a, 0x93, 0xc5, 0x53, 0xad, 0xec, 0xf6,
1456                 0xc8, 0x94, 0xee, 0x92, 0xea, 0xee, 0x7e, 0xea,
1457                 0xb9, 0x5f, 0xac, 0x59, 0x5d, 0x2e, 0x78, 0x53,
1458                 0x72, 0x81, 0x92, 0xdd, 0x1c, 0x63, 0xbe, 0x02,
1459                 0xeb, 0xa8, 0x1b, 0x2a, 0x6e, 0x72, 0xe3, 0x2d,
1460                 0x84, 0x0d, 0x8a, 0x22, 0xf6, 0xba, 0xab, 0x04,
1461                 0x8e, 0x04, 0x24, 0xdb, 0xcc, 0xe2, 0x69, 0xeb,
1462                 0x4e, 0xfa, 0x6b, 0x5b, 0xc8, 0xc0, 0xd9, 0x25,
1463                 0xcb, 0x40, 0x8d, 0x4b, 0x8e, 0xa0, 0xd4, 0x72,
1464                 0x98, 0x36, 0x46, 0x3b, 0x4f, 0x5f, 0x96, 0x84,
1465                 0x03, 0x28, 0x86, 0x4d, 0xa1, 0x8a, 0xd7, 0xb2,
1466                 0x5b, 0x27, 0x01, 0x80, 0x62, 0x49, 0x56, 0xb9,
1467                 0xa0, 0xa1, 0xe3, 0x6e, 0x22, 0x2a, 0x5d, 0x03,
1468                 0x86, 0x40, 0x36, 0x22, 0x5e, 0xd2, 0xe5, 0xc0,
1469                 0x6b, 0xfa, 0xac, 0x80, 0x4e, 0x09, 0x99, 0xbc,
1470                 0x2f, 0x9b, 0xcc, 0xf3, 0x4e, 0xf7, 0x99, 0x98,
1471                 0x11, 0x6e, 0x6f, 0x62, 0x22, 0x6b, 0x92, 0x95,
1472                 0x3b, 0xc3, 0xd2, 0x8e, 0x0f, 0x07, 0xc2, 0x51,
1473                 0x5c, 0x4d, 0xb2, 0x6e, 0xc0, 0x27, 0x73, 0xcd,
1474                 0x57, 0xb7, 0xf0, 0xe9, 0x2e, 0xc8, 0xe2, 0x0c,
1475                 0xd1, 0xb5, 0x0f, 0xff, 0xf9, 0xec, 0x38, 0xba,
1476                 0x97, 0xd6, 0x94, 0x9b, 0xd1, 0x79, 0xb6, 0x6a,
1477                 0x01, 0x17, 0xe4, 0x7e, 0xa6, 0xd5, 0x86, 0x19,
1478                 0xae, 0xf3, 0xf0, 0x62, 0x73, 0xc0, 0xf0, 0x0a,
1479                 0x7a, 0x96, 0x93, 0x72, 0x89, 0x7e, 0x25, 0x57,
1480                 0xf8, 0xf7, 0xd5, 0x1e, 0xe5, 0xac, 0xd6, 0x38,
1481                 0x4f, 0xe8, 0x81, 0xd1, 0x53, 0x41, 0x07, 0x2d,
1482                 0x58, 0x34, 0x1c, 0xef, 0x74, 0x2e, 0x61, 0xca,
1483                 0xd3, 0xeb, 0xd6, 0x93, 0x0a, 0xf2, 0xf2, 0x86,
1484                 0x9c, 0xe3, 0x7a, 0x52, 0xf5, 0x42, 0xf1, 0x8b,
1485                 0x10, 0xf2, 0x25, 0x68, 0x7e, 0x61, 0xb1, 0x19,
1486                 0xcf, 0x8f, 0x5a, 0x53, 0xb7, 0x68, 0x4f, 0x1a,
1487                 0x71, 0xe9, 0x83, 0x91, 0x3a, 0x78, 0x0f, 0xf7,
1488                 0xd4, 0x74, 0xf5, 0x06, 0xd2, 0x88, 0xb0, 0x06,
1489                 0xe5, 0xc0, 0xfb, 0xb3, 0x91, 0xad, 0xc0, 0x84,
1490                 0x31, 0xf2, 0x3a, 0xcf, 0x63, 0xe6, 0x4a, 0xd3,
1491                 0x78, 0xbe, 0xde, 0x73, 0x3e, 0x02, 0x8e, 0xb8,
1492                 0x3a, 0xf6, 0x55, 0xa7, 0xf8, 0x5a, 0xb5, 0x0e,
1493                 0x0c, 0xc5, 0xe5, 0x66, 0xd5, 0xd2, 0x18, 0xf3,
1494                 0xef, 0xa5, 0xc9, 0x68, 0x69, 0xe0, 0xcd, 0x00,
1495                 0x33, 0x99, 0x6e, 0xea, 0xcb, 0x06, 0x7a, 0xe1,
1496                 0xe1, 0x19, 0x0b, 0xe7, 0x08, 0xcd, 0x09, 0x1b,
1497                 0x85, 0xec, 0xc4, 0xd4, 0x75, 0xf0, 0xd6, 0xfb,
1498                 0x84, 0x95, 0x07, 0x44, 0xca, 0xa5, 0x2a, 0x6c,
1499                 0xc2, 0x00, 0x58, 0x08, 0x87, 0x9e, 0x0a, 0xd4,
1500                 0x06, 0xe2, 0x91, 0x5f, 0xb7, 0x1b, 0x11, 0xfa,
1501                 0x85, 0xfc, 0x7c, 0xf2, 0x0f, 0x6e, 0x3c, 0x8a,
1502                 0xe1, 0x0f, 0xa0, 0x33, 0x84, 0xce, 0x81, 0x4d,
1503                 0x32, 0x4d, 0xeb, 0x41, 0xcf, 0x5a, 0x05, 0x60,
1504                 0x47, 0x6c, 0x2a, 0xc4, 0x17, 0xd5, 0x16, 0x3a,
1505                 0xe4, 0xe7, 0xab, 0x84, 0x94, 0x22, 0xff, 0x56,
1506                 0xb0, 0x0c, 0x92, 0x6c, 0x19, 0x11, 0x4c, 0xb3,
1507                 0xed, 0x58, 0x48, 0x84, 0x2a, 0xe2, 0x19, 0x2a,
1508                 0xe1, 0xc0, 0x56, 0x82, 0x3c, 0x83, 0xb4, 0x58,
1509                 0x2d, 0xf0, 0xb5, 0x1e, 0x76, 0x85, 0x51, 0xc2,
1510                 0xe4, 0x95, 0x27, 0x96, 0xd1, 0x90, 0xc3, 0x17,
1511                 0x75, 0xa1, 0xbb, 0x46, 0x5f, 0xa6, 0xf2, 0xef,
1512                 0x71, 0x56, 0x92, 0xc5, 0x8a, 0x85, 0x52, 0xe4,
1513                 0x63, 0x21, 0x6f, 0x55, 0x85, 0x2b, 0x6b, 0x0d,
1514                 0xc9, 0x92, 0x77, 0x67, 0xe3, 0xff, 0x2a, 0x2b,
1515                 0x90, 0x01, 0x3d, 0x74, 0x63, 0x04, 0x61, 0x3c,
1516                 0x8e, 0xf8, 0xfc, 0x04, 0xdd, 0x21, 0x85, 0x92,
1517                 0x1e, 0x4d, 0x51, 0x8d, 0xb5, 0x6b, 0xf1, 0xda,
1518                 0x96, 0xf5, 0x8e, 0x3c, 0x38, 0x5a, 0xac, 0x9b,
1519                 0xba, 0x0c, 0x84, 0x5d, 0x50, 0x12, 0xc7, 0xc5,
1520                 0x7a, 0xcb, 0xb1, 0xfa, 0x16, 0x93, 0xdf, 0x98,
1521                 0xda, 0x3f, 0x49, 0xa3, 0x94, 0x78, 0x70, 0xc7,
1522                 0x0b, 0xb6, 0x91, 0xa6, 0x16, 0x2e, 0xcf, 0xfd,
1523                 0x51, 0x6a, 0x5b, 0xad, 0x7a, 0xdd, 0xa9, 0x48,
1524                 0x48, 0xac, 0xd6, 0x45, 0xbc, 0x23, 0x31, 0x1d,
1525                 0x86, 0x54, 0x8a, 0x7f, 0x04, 0x97, 0x71, 0x9e,
1526                 0xbc, 0x2e, 0x6b, 0xd9, 0x33, 0xc8, 0x20, 0xc9,
1527                 0xe0, 0x25, 0x86, 0x59, 0x15, 0xcf, 0x63, 0xe5,
1528                 0x99, 0xf1, 0x24, 0xf1, 0xba, 0xc4, 0x15, 0x02,
1529                 0xe2, 0xdb, 0xfe, 0x4a, 0xf8, 0x3b, 0x91, 0x13,
1530                 0x8d, 0x03, 0x81, 0x9f, 0xb3, 0x3f, 0x04, 0x03,
1531                 0x58, 0xc0, 0xef, 0x27, 0x82, 0x14, 0xd2, 0x7f,
1532                 0x93, 0x70, 0xb7, 0xb2, 0x02, 0x21, 0xb3, 0x07,
1533                 0x7f, 0x1c, 0xef, 0x88, 0xee, 0x29, 0x7a, 0x0b,
1534                 0x3d, 0x75, 0x5a, 0x93, 0xfe, 0x7f, 0x14, 0xf7,
1535                 0x4e, 0x4b, 0x7f, 0x21, 0x02, 0xad, 0xf9, 0x43,
1536                 0x29, 0x1a, 0xe8, 0x1b, 0xf5, 0x32, 0xb2, 0x96,
1537                 0xe6, 0xe8, 0x96, 0x20, 0x9b, 0x96, 0x8e, 0x7b,
1538                 0xfe, 0xd8, 0xc9, 0x9c, 0x65, 0x16, 0xd6, 0x68,
1539                 0x95, 0xf8, 0x22, 0xe2, 0xae, 0x84, 0x03, 0xfd,
1540                 0x87, 0xa2, 0x72, 0x79, 0x74, 0x95, 0xfa, 0xe1,
1541                 0xfe, 0xd0, 0x4e, 0x3d, 0x39, 0x2e, 0x67, 0x55,
1542                 0x71, 0x6c, 0x89, 0x33, 0x49, 0x0c, 0x1b, 0x46,
1543                 0x92, 0x31, 0x6f, 0xa6, 0xf0, 0x09, 0xbd, 0x2d,
1544                 0xe2, 0xca, 0xda, 0x18, 0x33, 0xce, 0x67, 0x37,
1545                 0xfd, 0x6f, 0xcb, 0x9d, 0xbd, 0x42, 0xbc, 0xb2,
1546                 0x9c, 0x28, 0xcd, 0x65, 0x3c, 0x61, 0xbc, 0xde,
1547                 0x9d, 0xe1, 0x2a, 0x3e, 0xbf, 0xee, 0x3c, 0xcb,
1548                 0xb1, 0x50, 0xa9, 0x2c, 0xbe, 0xb5, 0x43, 0xd0,
1549                 0xec, 0x29, 0xf9, 0x16, 0x6f, 0x31, 0xd9, 0x9b,
1550                 0x92, 0xb1, 0x32, 0xae, 0x0f, 0xb6, 0x9d, 0x0e,
1551                 0x25, 0x7f, 0x89, 0x1f, 0x1d, 0x01, 0x68, 0xab,
1552                 0x3d, 0xd1, 0x74, 0x5b, 0x4c, 0x38, 0x7f, 0x3d,
1553                 0x33, 0xa5, 0xa2, 0x9f, 0xda, 0x84, 0xa5, 0x82,
1554                 0x2d, 0x16, 0x66, 0x46, 0x08, 0x30, 0x14, 0x48,
1555                 0x5e, 0xca, 0xe3, 0xf4, 0x8c, 0xcb, 0x32, 0xc6,
1556                 0xf1, 0x43, 0x62, 0xc6, 0xef, 0x16, 0xfa, 0x43,
1557                 0xae, 0x9c, 0x53, 0xe3, 0x49, 0x45, 0x80, 0xfd,
1558                 0x1d, 0x8c, 0xa9, 0x6d, 0x77, 0x76, 0xaa, 0x40,
1559                 0xc4, 0x4e, 0x7b, 0x78, 0x6b, 0xe0, 0x1d, 0xce,
1560                 0x56, 0x3d, 0xf0, 0x11, 0xfe, 0x4f, 0x6a, 0x6d,
1561                 0x0f, 0x4f, 0x90, 0x38, 0x92, 0x17, 0xfa, 0x56,
1562                 0x12, 0xa6, 0xa1, 0x0a, 0xea, 0x2f, 0x50, 0xf9,
1563                 0x60, 0x66, 0x6c, 0x7d, 0x5a, 0x08, 0x8e, 0x3c,
1564                 0xf3, 0xf0, 0x33, 0x02, 0x11, 0x02, 0xfe, 0x4c,
1565                 0x56, 0x2b, 0x9f, 0x0c, 0xbd, 0x65, 0x8a, 0x83,
1566                 0xde, 0x7c, 0x05, 0x26, 0x93, 0x19, 0xcc, 0xf3,
1567                 0x71, 0x0e, 0xad, 0x2f, 0xb3, 0xc9, 0x38, 0x50,
1568                 0x64, 0xd5, 0x4c, 0x60, 0x5f, 0x02, 0x13, 0x34,
1569                 0xc9, 0x75, 0xc4, 0x60, 0xab, 0x2e, 0x17, 0x7d
1570 };
1571
1572 static const uint8_t AES_CBC_ciphertext_2048B[] = {
1573                 0x8b, 0x55, 0xbd, 0xfd, 0x2b, 0x35, 0x76, 0x5c,
1574                 0xd1, 0x90, 0xd7, 0x6a, 0x63, 0x1e, 0x39, 0x71,
1575                 0x0d, 0x5c, 0xd8, 0x03, 0x00, 0x75, 0xf1, 0x07,
1576                 0x03, 0x8d, 0x76, 0xeb, 0x3b, 0x00, 0x1e, 0x33,
1577                 0x88, 0xfc, 0x8f, 0x08, 0x4d, 0x33, 0xf1, 0x3c,
1578                 0xee, 0xd0, 0x5d, 0x19, 0x8b, 0x3c, 0x50, 0x86,
1579                 0xfd, 0x8d, 0x58, 0x21, 0xb4, 0xae, 0x0f, 0x81,
1580                 0xe9, 0x9f, 0xc9, 0xc0, 0x90, 0xf7, 0x04, 0x6f,
1581                 0x39, 0x1d, 0x8a, 0x3f, 0x8d, 0x32, 0x23, 0xb5,
1582                 0x1f, 0xcc, 0x8a, 0x12, 0x2d, 0x46, 0x82, 0x5e,
1583                 0x6a, 0x34, 0x8c, 0xb1, 0x93, 0x70, 0x3b, 0xde,
1584                 0x55, 0xaf, 0x16, 0x35, 0x99, 0x84, 0xd5, 0x88,
1585                 0xc9, 0x54, 0xb1, 0xb2, 0xd3, 0xeb, 0x9e, 0x55,
1586                 0x9a, 0xa9, 0xa7, 0xf5, 0xda, 0x29, 0xcf, 0xe1,
1587                 0x98, 0x64, 0x45, 0x77, 0xf2, 0x12, 0x69, 0x8f,
1588                 0x78, 0xd8, 0x82, 0x41, 0xb2, 0x9f, 0xe2, 0x1c,
1589                 0x63, 0x9b, 0x24, 0x81, 0x67, 0x95, 0xa2, 0xff,
1590                 0x26, 0x9d, 0x65, 0x48, 0x61, 0x30, 0x66, 0x41,
1591                 0x68, 0x84, 0xbb, 0x59, 0x14, 0x8e, 0x9a, 0x62,
1592                 0xb6, 0xca, 0xda, 0xbe, 0x7c, 0x41, 0x52, 0x6e,
1593                 0x1b, 0x86, 0xbf, 0x08, 0xeb, 0x37, 0x84, 0x60,
1594                 0xe4, 0xc4, 0x1e, 0xa8, 0x4c, 0x84, 0x60, 0x2f,
1595                 0x70, 0x90, 0xf2, 0x26, 0xe7, 0x65, 0x0c, 0xc4,
1596                 0x58, 0x36, 0x8e, 0x4d, 0xdf, 0xff, 0x9a, 0x39,
1597                 0x93, 0x01, 0xcf, 0x6f, 0x6d, 0xde, 0xef, 0x79,
1598                 0xb0, 0xce, 0xe2, 0x98, 0xdb, 0x85, 0x8d, 0x62,
1599                 0x9d, 0xb9, 0x63, 0xfd, 0xf0, 0x35, 0xb5, 0xa9,
1600                 0x1b, 0xf9, 0xe5, 0xd4, 0x2e, 0x22, 0x2d, 0xcc,
1601                 0x42, 0xbf, 0x0e, 0x51, 0xf7, 0x15, 0x07, 0x32,
1602                 0x75, 0x5b, 0x74, 0xbb, 0x00, 0xef, 0xd4, 0x66,
1603                 0x8b, 0xad, 0x71, 0x53, 0x94, 0xd7, 0x7d, 0x2c,
1604                 0x40, 0x3e, 0x69, 0xa0, 0x4c, 0x86, 0x5e, 0x06,
1605                 0xed, 0xdf, 0x22, 0xe2, 0x24, 0x25, 0x4e, 0x9b,
1606                 0x5f, 0x49, 0x74, 0xba, 0xed, 0xb1, 0xa6, 0xeb,
1607                 0xae, 0x3f, 0xc6, 0x9e, 0x0b, 0x29, 0x28, 0x9a,
1608                 0xb6, 0xb2, 0x74, 0x58, 0xec, 0xa6, 0x4a, 0xed,
1609                 0xe5, 0x10, 0x00, 0x85, 0xe1, 0x63, 0x41, 0x61,
1610                 0x30, 0x7c, 0x97, 0xcf, 0x75, 0xcf, 0xb6, 0xf3,
1611                 0xf7, 0xda, 0x35, 0x3f, 0x85, 0x8c, 0x64, 0xca,
1612                 0xb7, 0xea, 0x7f, 0xe4, 0xa3, 0x4d, 0x30, 0x84,
1613                 0x8c, 0x9c, 0x80, 0x5a, 0x50, 0xa5, 0x64, 0xae,
1614                 0x26, 0xd3, 0xb5, 0x01, 0x73, 0x36, 0x8a, 0x92,
1615                 0x49, 0xc4, 0x1a, 0x94, 0x81, 0x9d, 0xf5, 0x6c,
1616                 0x50, 0xe1, 0x58, 0x0b, 0x75, 0xdd, 0x6b, 0x6a,
1617                 0xca, 0x69, 0xea, 0xc3, 0x33, 0x90, 0x9f, 0x3b,
1618                 0x65, 0x5d, 0x5e, 0xee, 0x31, 0xb7, 0x32, 0xfd,
1619                 0x56, 0x83, 0xb6, 0xfb, 0xa8, 0x04, 0xfc, 0x1e,
1620                 0x11, 0xfb, 0x02, 0x23, 0x53, 0x49, 0x45, 0xb1,
1621                 0x07, 0xfc, 0xba, 0xe7, 0x5f, 0x5d, 0x2d, 0x7f,
1622                 0x9e, 0x46, 0xba, 0xe9, 0xb0, 0xdb, 0x32, 0x04,
1623                 0xa4, 0xa7, 0x98, 0xab, 0x91, 0xcd, 0x02, 0x05,
1624                 0xf5, 0x74, 0x31, 0x98, 0x83, 0x3d, 0x33, 0x11,
1625                 0x0e, 0xe3, 0x8d, 0xa8, 0xc9, 0x0e, 0xf3, 0xb9,
1626                 0x47, 0x67, 0xe9, 0x79, 0x2b, 0x34, 0xcd, 0x9b,
1627                 0x45, 0x75, 0x29, 0xf0, 0xbf, 0xcc, 0xda, 0x3a,
1628                 0x91, 0xb2, 0x15, 0x27, 0x7a, 0xe5, 0xf5, 0x6a,
1629                 0x5e, 0xbe, 0x2c, 0x98, 0xe8, 0x40, 0x96, 0x4f,
1630                 0x8a, 0x09, 0xfd, 0xf6, 0xb2, 0xe7, 0x45, 0xb6,
1631                 0x08, 0xc1, 0x69, 0xe1, 0xb3, 0xc4, 0x24, 0x34,
1632                 0x07, 0x85, 0xd5, 0xa9, 0x78, 0xca, 0xfa, 0x4b,
1633                 0x01, 0x19, 0x4d, 0x95, 0xdc, 0xa5, 0xc1, 0x9c,
1634                 0xec, 0x27, 0x5b, 0xa6, 0x54, 0x25, 0xbd, 0xc8,
1635                 0x0a, 0xb7, 0x11, 0xfb, 0x4e, 0xeb, 0x65, 0x2e,
1636                 0xe1, 0x08, 0x9c, 0x3a, 0x45, 0x44, 0x33, 0xef,
1637                 0x0d, 0xb9, 0xff, 0x3e, 0x68, 0x9c, 0x61, 0x2b,
1638                 0x11, 0xb8, 0x5c, 0x47, 0x0f, 0x94, 0xf2, 0xf8,
1639                 0x0b, 0xbb, 0x99, 0x18, 0x85, 0xa3, 0xba, 0x44,
1640                 0xf3, 0x79, 0xb3, 0x63, 0x2c, 0x1f, 0x2a, 0x35,
1641                 0x3b, 0x23, 0x98, 0xab, 0xf4, 0x16, 0x36, 0xf8,
1642                 0xde, 0x86, 0xa4, 0xd4, 0x75, 0xff, 0x51, 0xf9,
1643                 0xeb, 0x42, 0x5f, 0x55, 0xe2, 0xbe, 0xd1, 0x5b,
1644                 0xb5, 0x38, 0xeb, 0xb4, 0x4d, 0xec, 0xec, 0x99,
1645                 0xe1, 0x39, 0x43, 0xaa, 0x64, 0xf7, 0xc9, 0xd8,
1646                 0xf2, 0x9a, 0x71, 0x43, 0x39, 0x17, 0xe8, 0xa8,
1647                 0xa2, 0xe2, 0xa4, 0x2c, 0x18, 0x11, 0x49, 0xdf,
1648                 0x18, 0xdd, 0x85, 0x6e, 0x65, 0x96, 0xe2, 0xba,
1649                 0xa1, 0x0a, 0x2c, 0xca, 0xdc, 0x5f, 0xe4, 0xf4,
1650                 0x35, 0x03, 0xb2, 0xa9, 0xda, 0xcf, 0xb7, 0x6d,
1651                 0x65, 0x82, 0x82, 0x67, 0x9d, 0x0e, 0xf3, 0xe8,
1652                 0x85, 0x6c, 0x69, 0xb8, 0x4c, 0xa6, 0xc6, 0x2e,
1653                 0x40, 0xb5, 0x54, 0x28, 0x95, 0xe4, 0x57, 0xe0,
1654                 0x5b, 0xf8, 0xde, 0x59, 0xe0, 0xfd, 0x89, 0x48,
1655                 0xac, 0x56, 0x13, 0x54, 0xb9, 0x1b, 0xf5, 0x59,
1656                 0x97, 0xb6, 0xb3, 0xe8, 0xac, 0x2d, 0xfc, 0xd2,
1657                 0xea, 0x57, 0x96, 0x57, 0xa8, 0x26, 0x97, 0x2c,
1658                 0x01, 0x89, 0x56, 0xea, 0xec, 0x8c, 0x53, 0xd5,
1659                 0xd7, 0x9e, 0xc9, 0x98, 0x0b, 0xad, 0x03, 0x75,
1660                 0xa0, 0x6e, 0x98, 0x8b, 0x97, 0x8d, 0x8d, 0x85,
1661                 0x7d, 0x74, 0xa7, 0x2d, 0xde, 0x67, 0x0c, 0xcd,
1662                 0x54, 0xb8, 0x15, 0x7b, 0xeb, 0xf5, 0x84, 0xb9,
1663                 0x78, 0xab, 0xd8, 0x68, 0x91, 0x1f, 0x6a, 0xa6,
1664                 0x28, 0x22, 0xf7, 0x00, 0x49, 0x00, 0xbe, 0x41,
1665                 0x71, 0x0a, 0xf5, 0xe7, 0x9f, 0xb4, 0x11, 0x41,
1666                 0x3f, 0xcd, 0xa9, 0xa9, 0x01, 0x8b, 0x6a, 0xeb,
1667                 0x54, 0x4c, 0x58, 0x92, 0x68, 0x02, 0x0e, 0xe9,
1668                 0xed, 0x65, 0x4c, 0xfb, 0x95, 0x48, 0x58, 0xa2,
1669                 0xaa, 0x57, 0x69, 0x13, 0x82, 0x0c, 0x2c, 0x4b,
1670                 0x5d, 0x4e, 0x18, 0x30, 0xef, 0x1c, 0xb1, 0x9d,
1671                 0x05, 0x05, 0x02, 0x1c, 0x97, 0xc9, 0x48, 0xfe,
1672                 0x5e, 0x7b, 0x77, 0xa3, 0x1f, 0x2a, 0x81, 0x42,
1673                 0xf0, 0x4b, 0x85, 0x12, 0x9c, 0x1f, 0x44, 0xb1,
1674                 0x14, 0x91, 0x92, 0x65, 0x77, 0xb1, 0x87, 0xa2,
1675                 0xfc, 0xa4, 0xe7, 0xd2, 0x9b, 0xf2, 0x17, 0xf0,
1676                 0x30, 0x1c, 0x8d, 0x33, 0xbc, 0x25, 0x28, 0x48,
1677                 0xfd, 0x30, 0x79, 0x0a, 0x99, 0x3e, 0xb4, 0x0f,
1678                 0x1e, 0xa6, 0x68, 0x76, 0x19, 0x76, 0x29, 0xac,
1679                 0x5d, 0xb8, 0x1e, 0x42, 0xd6, 0x85, 0x04, 0xbf,
1680                 0x64, 0x1c, 0x2d, 0x53, 0xe9, 0x92, 0x78, 0xf8,
1681                 0xc3, 0xda, 0x96, 0x92, 0x10, 0x6f, 0x45, 0x85,
1682                 0xaf, 0x5e, 0xcc, 0xa8, 0xc0, 0xc6, 0x2e, 0x73,
1683                 0x51, 0x3f, 0x5e, 0xd7, 0x52, 0x33, 0x71, 0x12,
1684                 0x6d, 0x85, 0xee, 0xea, 0x85, 0xa8, 0x48, 0x2b,
1685                 0x40, 0x64, 0x6d, 0x28, 0x73, 0x16, 0xd7, 0x82,
1686                 0xd9, 0x90, 0xed, 0x1f, 0xa7, 0x5c, 0xb1, 0x5c,
1687                 0x27, 0xb9, 0x67, 0x8b, 0xb4, 0x17, 0x13, 0x83,
1688                 0x5f, 0x09, 0x72, 0x0a, 0xd7, 0xa0, 0xec, 0x81,
1689                 0x59, 0x19, 0xb9, 0xa6, 0x5a, 0x37, 0x34, 0x14,
1690                 0x47, 0xf6, 0xe7, 0x6c, 0xd2, 0x09, 0x10, 0xe7,
1691                 0xdd, 0xbb, 0x02, 0xd1, 0x28, 0xfa, 0x01, 0x2c,
1692                 0x93, 0x64, 0x2e, 0x1b, 0x4c, 0x02, 0x52, 0xcb,
1693                 0x07, 0xa1, 0xb6, 0x46, 0x02, 0x80, 0xd9, 0x8f,
1694                 0x5c, 0x62, 0xbe, 0x78, 0x9e, 0x75, 0xc4, 0x97,
1695                 0x91, 0x39, 0x12, 0x65, 0xb9, 0x3b, 0xc2, 0xd1,
1696                 0xaf, 0xf2, 0x1f, 0x4e, 0x4d, 0xd1, 0xf0, 0x9f,
1697                 0xb7, 0x12, 0xfd, 0xe8, 0x75, 0x18, 0xc0, 0x9d,
1698                 0x8c, 0x70, 0xff, 0x77, 0x05, 0xb6, 0x1a, 0x1f,
1699                 0x96, 0x48, 0xf6, 0xfe, 0xd5, 0x5d, 0x98, 0xa5,
1700                 0x72, 0x1c, 0x84, 0x76, 0x3e, 0xb8, 0x87, 0x37,
1701                 0xdd, 0xd4, 0x3a, 0x45, 0xdd, 0x09, 0xd8, 0xe7,
1702                 0x09, 0x2f, 0x3e, 0x33, 0x9e, 0x7b, 0x8c, 0xe4,
1703                 0x85, 0x12, 0x4e, 0xf8, 0x06, 0xb7, 0xb1, 0x85,
1704                 0x24, 0x96, 0xd8, 0xfe, 0x87, 0x92, 0x81, 0xb1,
1705                 0xa3, 0x38, 0xb9, 0x56, 0xe1, 0xf6, 0x36, 0x41,
1706                 0xbb, 0xd6, 0x56, 0x69, 0x94, 0x57, 0xb3, 0xa4,
1707                 0xca, 0xa4, 0xe1, 0x02, 0x3b, 0x96, 0x71, 0xe0,
1708                 0xb2, 0x2f, 0x85, 0x48, 0x1b, 0x4a, 0x41, 0x80,
1709                 0x4b, 0x9c, 0xe0, 0xc9, 0x39, 0xb8, 0xb1, 0xca,
1710                 0x64, 0x77, 0x46, 0x58, 0xe6, 0x84, 0xd5, 0x2b,
1711                 0x65, 0xce, 0xe9, 0x09, 0xa3, 0xaa, 0xfb, 0x83,
1712                 0xa9, 0x28, 0x68, 0xfd, 0xcd, 0xfd, 0x76, 0x83,
1713                 0xe1, 0x20, 0x22, 0x77, 0x3a, 0xa3, 0xb2, 0x93,
1714                 0x14, 0x91, 0xfc, 0xe2, 0x17, 0x63, 0x2b, 0xa6,
1715                 0x29, 0x38, 0x7b, 0x9b, 0x8b, 0x15, 0x77, 0xd6,
1716                 0xaa, 0x92, 0x51, 0x53, 0x50, 0xff, 0xa0, 0x35,
1717                 0xa0, 0x59, 0x7d, 0xf0, 0x11, 0x23, 0x49, 0xdf,
1718                 0x5a, 0x21, 0xc2, 0xfe, 0x35, 0xa0, 0x1d, 0xe2,
1719                 0xae, 0xa2, 0x8a, 0x61, 0x5b, 0xf7, 0xf1, 0x1c,
1720                 0x1c, 0xec, 0xc4, 0xf6, 0xdc, 0xaa, 0xc8, 0xc2,
1721                 0xe5, 0xa1, 0x2e, 0x14, 0xe5, 0xc6, 0xc9, 0x73,
1722                 0x03, 0x78, 0xeb, 0xed, 0xe0, 0x3e, 0xc5, 0xf4,
1723                 0xf1, 0x50, 0xb2, 0x01, 0x91, 0x96, 0xf5, 0xbb,
1724                 0xe1, 0x32, 0xcd, 0xa8, 0x66, 0xbf, 0x73, 0x85,
1725                 0x94, 0xd6, 0x7e, 0x68, 0xc5, 0xe4, 0xed, 0xd5,
1726                 0xe3, 0x67, 0x4c, 0xa5, 0xb3, 0x1f, 0xdf, 0xf8,
1727                 0xb3, 0x73, 0x5a, 0xac, 0xeb, 0x46, 0x16, 0x24,
1728                 0xab, 0xca, 0xa4, 0xdd, 0x87, 0x0e, 0x24, 0x83,
1729                 0x32, 0x04, 0x4c, 0xd8, 0xda, 0x7d, 0xdc, 0xe3,
1730                 0x01, 0x93, 0xf3, 0xc1, 0x5b, 0xbd, 0xc3, 0x1d,
1731                 0x40, 0x62, 0xde, 0x94, 0x03, 0x85, 0x91, 0x2a,
1732                 0xa0, 0x25, 0x10, 0xd3, 0x32, 0x9f, 0x93, 0x00,
1733                 0xa7, 0x8a, 0xfa, 0x77, 0x7c, 0xaf, 0x4d, 0xc8,
1734                 0x7a, 0xf3, 0x16, 0x2b, 0xba, 0xeb, 0x74, 0x51,
1735                 0xb8, 0xdd, 0x32, 0xad, 0x68, 0x7d, 0xdd, 0xca,
1736                 0x60, 0x98, 0xc9, 0x9b, 0xb6, 0x5d, 0x4d, 0x3a,
1737                 0x66, 0x8a, 0xbe, 0x05, 0xf9, 0x0c, 0xc5, 0xba,
1738                 0x52, 0x82, 0x09, 0x1f, 0x5a, 0x66, 0x89, 0x69,
1739                 0xa3, 0x5d, 0x93, 0x50, 0x7d, 0x44, 0xc3, 0x2a,
1740                 0xb8, 0xab, 0xec, 0xa6, 0x5a, 0xae, 0x4a, 0x6a,
1741                 0xcd, 0xfd, 0xb6, 0xff, 0x3d, 0x98, 0x05, 0xd9,
1742                 0x5b, 0x29, 0xc4, 0x6f, 0xe0, 0x76, 0xe2, 0x3f,
1743                 0xec, 0xd7, 0xa4, 0x91, 0x63, 0xf5, 0x4e, 0x4b,
1744                 0xab, 0x20, 0x8c, 0x3a, 0x41, 0xed, 0x8b, 0x4b,
1745                 0xb9, 0x01, 0x21, 0xc0, 0x6d, 0xfd, 0x70, 0x5b,
1746                 0x20, 0x92, 0x41, 0x89, 0x74, 0xb7, 0xe9, 0x8b,
1747                 0xfc, 0x6d, 0x17, 0x3f, 0x7f, 0x89, 0x3d, 0x6b,
1748                 0x8f, 0xbc, 0xd2, 0x57, 0xe9, 0xc9, 0x6e, 0xa7,
1749                 0x19, 0x26, 0x18, 0xad, 0xef, 0xb5, 0x87, 0xbf,
1750                 0xb8, 0xa8, 0xd6, 0x7d, 0xdd, 0x5f, 0x94, 0x54,
1751                 0x09, 0x92, 0x2b, 0xf5, 0x04, 0xf7, 0x36, 0x69,
1752                 0x8e, 0xf4, 0xdc, 0x1d, 0x6e, 0x55, 0xbb, 0xe9,
1753                 0x13, 0x05, 0x83, 0x35, 0x9c, 0xed, 0xcf, 0x8c,
1754                 0x26, 0x8c, 0x7b, 0xc7, 0x0b, 0xba, 0xfd, 0xe2,
1755                 0x84, 0x5c, 0x2a, 0x79, 0x43, 0x99, 0xb2, 0xc3,
1756                 0x82, 0x87, 0xc8, 0xcd, 0x37, 0x6d, 0xa1, 0x2b,
1757                 0x39, 0xb2, 0x38, 0x99, 0xd9, 0xfc, 0x02, 0x15,
1758                 0x55, 0x21, 0x62, 0x59, 0xeb, 0x00, 0x86, 0x08,
1759                 0x20, 0xbe, 0x1a, 0x62, 0x4d, 0x7e, 0xdf, 0x68,
1760                 0x73, 0x5b, 0x5f, 0xaf, 0x84, 0x96, 0x2e, 0x1f,
1761                 0x6b, 0x03, 0xc9, 0xa6, 0x75, 0x18, 0xe9, 0xd4,
1762                 0xbd, 0xc8, 0xec, 0x9a, 0x5a, 0xb3, 0x99, 0xab,
1763                 0x5f, 0x7c, 0x08, 0x7f, 0x69, 0x4d, 0x52, 0xa2,
1764                 0x30, 0x17, 0x3b, 0x16, 0x15, 0x1b, 0x11, 0x62,
1765                 0x3e, 0x80, 0x4b, 0x85, 0x7c, 0x9c, 0xd1, 0x3a,
1766                 0x13, 0x01, 0x5e, 0x45, 0xf1, 0xc8, 0x5f, 0xcd,
1767                 0x0e, 0x21, 0xf5, 0x82, 0xd4, 0x7b, 0x5c, 0x45,
1768                 0x27, 0x6b, 0xef, 0xfe, 0xb8, 0xc0, 0x6f, 0xdc,
1769                 0x60, 0x7b, 0xe4, 0xd5, 0x75, 0x71, 0xe6, 0xe8,
1770                 0x7d, 0x6b, 0x6d, 0x80, 0xaf, 0x76, 0x41, 0x58,
1771                 0xb7, 0xac, 0xb7, 0x13, 0x2f, 0x81, 0xcc, 0xf9,
1772                 0x19, 0x97, 0xe8, 0xee, 0x40, 0x91, 0xfc, 0x89,
1773                 0x13, 0x1e, 0x67, 0x9a, 0xdb, 0x8f, 0x8f, 0xc7,
1774                 0x4a, 0xc9, 0xaf, 0x2f, 0x67, 0x01, 0x3c, 0xb8,
1775                 0xa8, 0x3e, 0x78, 0x93, 0x1b, 0xdf, 0xbb, 0x34,
1776                 0x0b, 0x1a, 0xfa, 0xc2, 0x2d, 0xc5, 0x1c, 0xec,
1777                 0x97, 0x4f, 0x48, 0x41, 0x15, 0x0e, 0x75, 0xed,
1778                 0x66, 0x8c, 0x17, 0x7f, 0xb1, 0x48, 0x13, 0xc1,
1779                 0xfb, 0x60, 0x06, 0xf9, 0x72, 0x41, 0x3e, 0xcf,
1780                 0x6e, 0xb6, 0xc8, 0xeb, 0x4b, 0x5a, 0xd2, 0x0c,
1781                 0x28, 0xda, 0x02, 0x7a, 0x46, 0x21, 0x42, 0xb5,
1782                 0x34, 0xda, 0xcb, 0x5e, 0xbd, 0x66, 0x5c, 0xca,
1783                 0xff, 0x52, 0x43, 0x89, 0xf9, 0x10, 0x9a, 0x9e,
1784                 0x9b, 0xe3, 0xb0, 0x51, 0xe9, 0xf3, 0x0a, 0x35,
1785                 0x77, 0x54, 0xcc, 0xac, 0xa6, 0xf1, 0x2e, 0x36,
1786                 0x89, 0xac, 0xc5, 0xc6, 0x62, 0x5a, 0xc0, 0x6d,
1787                 0xc4, 0xe1, 0xf7, 0x64, 0x30, 0xff, 0x11, 0x40,
1788                 0x13, 0x89, 0xd8, 0xd7, 0x73, 0x3f, 0x93, 0x08,
1789                 0x68, 0xab, 0x66, 0x09, 0x1a, 0xea, 0x78, 0xc9,
1790                 0x52, 0xf2, 0xfd, 0x93, 0x1b, 0x94, 0xbe, 0x5c,
1791                 0xe5, 0x00, 0x6e, 0x00, 0xb9, 0xea, 0x27, 0xaa,
1792                 0xb3, 0xee, 0xe3, 0xc8, 0x6a, 0xb0, 0xc1, 0x8e,
1793                 0x9b, 0x54, 0x40, 0x10, 0x96, 0x06, 0xe8, 0xb3,
1794                 0xf5, 0x55, 0x77, 0xd7, 0x5c, 0x94, 0xc1, 0x74,
1795                 0xf3, 0x07, 0x64, 0xac, 0x1c, 0xde, 0xc7, 0x22,
1796                 0xb0, 0xbf, 0x2a, 0x5a, 0xc0, 0x8f, 0x8a, 0x83,
1797                 0x50, 0xc2, 0x5e, 0x97, 0xa0, 0xbe, 0x49, 0x7e,
1798                 0x47, 0xaf, 0xa7, 0x20, 0x02, 0x35, 0xa4, 0x57,
1799                 0xd9, 0x26, 0x63, 0xdb, 0xf1, 0x34, 0x42, 0x89,
1800                 0x36, 0xd1, 0x77, 0x6f, 0xb1, 0xea, 0x79, 0x7e,
1801                 0x95, 0x10, 0x5a, 0xee, 0xa3, 0xae, 0x6f, 0xba,
1802                 0xa9, 0xef, 0x5a, 0x7e, 0x34, 0x03, 0x04, 0x07,
1803                 0x92, 0xd6, 0x07, 0x79, 0xaa, 0x14, 0x90, 0x97,
1804                 0x05, 0x4d, 0xa6, 0x27, 0x10, 0x5c, 0x25, 0x24,
1805                 0xcb, 0xcc, 0xf6, 0x77, 0x9e, 0x43, 0x23, 0xd4,
1806                 0x98, 0xef, 0x22, 0xa8, 0xad, 0xf2, 0x26, 0x08,
1807                 0x59, 0x69, 0xa4, 0xc3, 0x97, 0xe0, 0x5c, 0x6f,
1808                 0xeb, 0x3d, 0xd4, 0x62, 0x6e, 0x80, 0x61, 0x02,
1809                 0xf4, 0xfc, 0x94, 0x79, 0xbb, 0x4e, 0x6d, 0xd7,
1810                 0x30, 0x5b, 0x10, 0x11, 0x5a, 0x3d, 0xa7, 0x50,
1811                 0x1d, 0x9a, 0x13, 0x5f, 0x4f, 0xa8, 0xa7, 0xb6,
1812                 0x39, 0xc7, 0xea, 0xe6, 0x19, 0x61, 0x69, 0xc7,
1813                 0x9a, 0x3a, 0xeb, 0x9d, 0xdc, 0xf7, 0x06, 0x37,
1814                 0xbd, 0xac, 0xe3, 0x18, 0xff, 0xfe, 0x11, 0xdb,
1815                 0x67, 0x42, 0xb4, 0xea, 0xa8, 0xbd, 0xb0, 0x76,
1816                 0xd2, 0x74, 0x32, 0xc2, 0xa4, 0x9c, 0xe7, 0x60,
1817                 0xc5, 0x30, 0x9a, 0x57, 0x66, 0xcd, 0x0f, 0x02,
1818                 0x4c, 0xea, 0xe9, 0xd3, 0x2a, 0x5c, 0x09, 0xc2,
1819                 0xff, 0x6a, 0xde, 0x5d, 0xb7, 0xe9, 0x75, 0x6b,
1820                 0x29, 0x94, 0xd6, 0xf7, 0xc3, 0xdf, 0xfb, 0x70,
1821                 0xec, 0xb5, 0x8c, 0xb0, 0x78, 0x7a, 0xee, 0x52,
1822                 0x5f, 0x8c, 0xae, 0x85, 0xe5, 0x98, 0xa2, 0xb7,
1823                 0x7c, 0x02, 0x2a, 0xcc, 0x9e, 0xde, 0x99, 0x5f,
1824                 0x84, 0x20, 0xbb, 0xdc, 0xf2, 0xd2, 0x13, 0x46,
1825                 0x3c, 0xd6, 0x4d, 0xe7, 0x50, 0xef, 0x55, 0xc3,
1826                 0x96, 0x9f, 0xec, 0x6c, 0xd8, 0xe2, 0xea, 0xed,
1827                 0xc7, 0x33, 0xc9, 0xb3, 0x1c, 0x4f, 0x1d, 0x83,
1828                 0x1d, 0xe4, 0xdd, 0xb2, 0x24, 0x8f, 0xf9, 0xf5
1829 };
1830
1831
1832 static const uint8_t HMAC_SHA256_ciphertext_64B_digest[] = {
1833                 0xc5, 0x6d, 0x4f, 0x29, 0xf4, 0xd2, 0xcc, 0x87,
1834                 0x3c, 0x81, 0x02, 0x6d, 0x38, 0x7a, 0x67, 0x3e,
1835                 0x95, 0x9c, 0x5c, 0x8f, 0xda, 0x5c, 0x06, 0xe0,
1836                 0x65, 0xf1, 0x6c, 0x51, 0x52, 0x49, 0x3e, 0x5f
1837 };
1838
1839 static const uint8_t HMAC_SHA256_ciphertext_128B_digest[] = {
1840                 0x76, 0x64, 0x2d, 0x69, 0x71, 0x5d, 0x6a, 0xd8,
1841                 0x9f, 0x74, 0x11, 0x2f, 0x58, 0xe0, 0x4a, 0x2f,
1842                 0x6c, 0x88, 0x5e, 0x4d, 0x9c, 0x79, 0x83, 0x1c,
1843                 0x8a, 0x14, 0xd0, 0x07, 0xfb, 0xbf, 0x6c, 0x8f
1844 };
1845
1846 static const uint8_t HMAC_SHA256_ciphertext_256B_digest[] = {
1847                 0x05, 0xa7, 0x44, 0xcd, 0x91, 0x8c, 0x95, 0xcf,
1848                 0x7b, 0x8f, 0xd3, 0x90, 0x86, 0x7e, 0x7b, 0xb9,
1849                 0x05, 0xd6, 0x6e, 0x7a, 0xc1, 0x7b, 0x26, 0xff,
1850                 0xd3, 0x4b, 0xe0, 0x22, 0x8b, 0xa8, 0x47, 0x52
1851 };
1852
1853 static const uint8_t HMAC_SHA256_ciphertext_512B_digest[] = {
1854                 0x08, 0xb7, 0x29, 0x54, 0x18, 0x7e, 0x97, 0x49,
1855                 0xc6, 0x7c, 0x9f, 0x94, 0xa5, 0x4f, 0xa2, 0x25,
1856                 0xd0, 0xe2, 0x30, 0x7b, 0xad, 0x93, 0xc9, 0x12,
1857                 0x0f, 0xf0, 0xf0, 0x71, 0xc2, 0xf6, 0x53, 0x8f
1858 };
1859
1860 static const uint8_t HMAC_SHA256_ciphertext_768B_digest[] = {
1861                 0xe4, 0x3e, 0x73, 0x93, 0x03, 0xaf, 0x6f, 0x9c,
1862                 0xca, 0x57, 0x3b, 0x4a, 0x6e, 0x83, 0x58, 0xf5,
1863                 0x66, 0xc2, 0xb4, 0xa7, 0xe0, 0xee, 0x63, 0x6b,
1864                 0x48, 0xb7, 0x50, 0x45, 0x69, 0xdf, 0x5c, 0x5b
1865 };
1866
1867 static const uint8_t HMAC_SHA256_ciphertext_1024B_digest[] = {
1868                 0x03, 0xb9, 0x96, 0x26, 0xdc, 0x1c, 0xab, 0xe2,
1869                 0xf5, 0x70, 0x55, 0x15, 0x67, 0x6e, 0x48, 0x11,
1870                 0xe7, 0x67, 0xea, 0xfa, 0x5c, 0x6b, 0x28, 0x22,
1871                 0xc9, 0x0e, 0x67, 0x04, 0xb3, 0x71, 0x7f, 0x88
1872 };
1873
1874 static const uint8_t HMAC_SHA256_ciphertext_1280B_digest[] = {
1875                 0x01, 0x91, 0xb8, 0x78, 0xd3, 0x21, 0x74, 0xa5,
1876                 0x1c, 0x8b, 0xd4, 0xd2, 0xc0, 0x49, 0xd7, 0xd2,
1877                 0x16, 0x46, 0x66, 0x85, 0x50, 0x6d, 0x08, 0xcc,
1878                 0xc7, 0x0a, 0xa3, 0x71, 0xcc, 0xde, 0xee, 0xdc
1879 };
1880
1881 static const uint8_t HMAC_SHA256_ciphertext_1536B_digest[] = {
1882                 0xf2, 0xe5, 0xe9, 0x57, 0x53, 0xd7, 0x69, 0x28,
1883                 0x7b, 0x69, 0xb5, 0x49, 0xa3, 0x31, 0x56, 0x5f,
1884                 0xa4, 0xe9, 0x87, 0x26, 0x2f, 0xe0, 0x2d, 0xd6,
1885                 0x08, 0x44, 0x01, 0x71, 0x0c, 0x93, 0x85, 0x84
1886 };
1887
1888 static const uint8_t HMAC_SHA256_ciphertext_1792B_digest[] = {
1889                 0xf6, 0x57, 0x62, 0x01, 0xbf, 0x2d, 0xea, 0x4a,
1890                 0xef, 0x43, 0x85, 0x60, 0x18, 0xdf, 0x8b, 0xb4,
1891                 0x60, 0xc0, 0xfd, 0x2f, 0x90, 0x15, 0xe6, 0x91,
1892                 0x56, 0x61, 0x68, 0x7f, 0x5e, 0x92, 0xa8, 0xdd
1893 };
1894
1895 static const uint8_t HMAC_SHA256_ciphertext_2048B_digest[] = {
1896                 0x81, 0x1a, 0x29, 0xbc, 0x6b, 0x9f, 0xbb, 0xb8,
1897                 0xef, 0x71, 0x7b, 0x1f, 0x6f, 0xd4, 0x7e, 0x68,
1898                 0x3a, 0x9c, 0xb9, 0x98, 0x22, 0x81, 0xfa, 0x95,
1899                 0xee, 0xbc, 0x7f, 0x23, 0x29, 0x88, 0x76, 0xb8
1900 };
1901
1902 struct crypto_data_params {
1903         const char *name;
1904         uint16_t length;
1905         const char *plaintext;
1906         struct crypto_expected_output {
1907                 const uint8_t *ciphertext;
1908                 const uint8_t *digest;
1909         } expected;
1910 };
1911
1912 #define MAX_PACKET_SIZE_INDEX   10
1913
1914 struct crypto_data_params aes_cbc_hmac_sha256_output[MAX_PACKET_SIZE_INDEX] = {
1915         { "64B", 64, &plaintext_quote[sizeof(plaintext_quote) - 1 - 64],
1916                 { AES_CBC_ciphertext_64B, HMAC_SHA256_ciphertext_64B_digest } },
1917         { "128B", 128, &plaintext_quote[sizeof(plaintext_quote) - 1 - 128],
1918                 { AES_CBC_ciphertext_128B, HMAC_SHA256_ciphertext_128B_digest } },
1919         { "256B", 256, &plaintext_quote[sizeof(plaintext_quote) - 1 - 256],
1920                 { AES_CBC_ciphertext_256B, HMAC_SHA256_ciphertext_256B_digest } },
1921         { "512B", 512, &plaintext_quote[sizeof(plaintext_quote) - 1 - 512],
1922                 { AES_CBC_ciphertext_512B, HMAC_SHA256_ciphertext_512B_digest } },
1923         { "768B", 768, &plaintext_quote[sizeof(plaintext_quote) - 1 - 768],
1924                 { AES_CBC_ciphertext_768B, HMAC_SHA256_ciphertext_768B_digest } },
1925         { "1024B", 1024, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1024],
1926                 { AES_CBC_ciphertext_1024B, HMAC_SHA256_ciphertext_1024B_digest } },
1927         { "1280B", 1280, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1280],
1928                 { AES_CBC_ciphertext_1280B, HMAC_SHA256_ciphertext_1280B_digest } },
1929         { "1536B", 1536, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1536],
1930                 { AES_CBC_ciphertext_1536B, HMAC_SHA256_ciphertext_1536B_digest } },
1931         { "1792B", 1792, &plaintext_quote[sizeof(plaintext_quote) - 1 - 1792],
1932                 { AES_CBC_ciphertext_1792B, HMAC_SHA256_ciphertext_1792B_digest } },
1933         { "2048B", 2048, &plaintext_quote[sizeof(plaintext_quote) - 1 - 2048],
1934                 { AES_CBC_ciphertext_2048B, HMAC_SHA256_ciphertext_2048B_digest } }
1935 };
1936
1937 static int
1938 test_perf_crypto_qp_vary_burst_size(uint16_t dev_num)
1939 {
1940         uint32_t num_to_submit = 4096;
1941         struct rte_crypto_op *c_ops[num_to_submit];
1942         struct rte_crypto_op *proc_ops[num_to_submit];
1943         uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
1944         uint32_t burst_sent, burst_received;
1945         uint32_t i, burst_size, num_sent, num_received;
1946         struct crypto_testsuite_params *ts_params = &testsuite_params;
1947         struct crypto_unittest_params *ut_params = &unittest_params;
1948         struct crypto_data_params *data_params = aes_cbc_hmac_sha256_output;
1949
1950         if (rte_cryptodev_count() == 0) {
1951                 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
1952                 return TEST_FAILED;
1953         }
1954
1955         /* Setup Cipher Parameters */
1956         ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1957         ut_params->cipher_xform.next = &ut_params->auth_xform;
1958
1959         ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC;
1960         ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
1961         ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key;
1962         ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC;
1963         ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
1964         ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC;
1965
1966         /* Setup HMAC Parameters */
1967         ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1968         ut_params->auth_xform.next = NULL;
1969
1970         ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_VERIFY;
1971         ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA256_HMAC;
1972         ut_params->auth_xform.auth.key.data = hmac_sha256_key;
1973         ut_params->auth_xform.auth.key.length = HMAC_KEY_LENGTH_SHA256;
1974         ut_params->auth_xform.auth.digest_length = DIGEST_BYTE_LENGTH_SHA256;
1975
1976         /* Create Crypto session*/
1977
1978         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
1979
1980         rte_cryptodev_sym_session_init(ts_params->dev_id, test_crypto_session,
1981                         &ut_params->cipher_xform, ts_params->sess_mp);
1982
1983         TEST_ASSERT_NOT_NULL(test_crypto_session, "Session creation failed");
1984
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");
1991
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");
1996
1997                 rte_memcpy(ut_params->digest, data_params[0].expected.digest,
1998                         DIGEST_BYTE_LENGTH_SHA256);
1999
2000
2001                 struct rte_crypto_op *op =
2002                                 rte_crypto_op_alloc(ts_params->op_mpool,
2003                                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2004
2005                 rte_crypto_op_attach_sym_session(op, test_crypto_session);
2006
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
2011                 op->sym->auth.data.offset = 0;
2012                 op->sym->auth.data.length = data_params[0].length;
2013
2014                 rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
2015                                 aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC);
2016
2017                 op->sym->cipher.data.offset = 0;
2018                 op->sym->cipher.data.length = data_params[0].length;
2019
2020                 op->sym->m_src = m;
2021
2022                 c_ops[i] = op;
2023         }
2024
2025         printf("\nTest to measure the IA cycle cost using AES128_CBC_SHA256_HMAC "
2026                         "algorithm with a constant request size of %u.",
2027                         data_params[0].length);
2028         printf("\nThis test will keep retries at 0 and only measure IA cycle "
2029                         "cost for each request.");
2030         printf("\nDev No\tQP No\tNum Sent\tNum Received\tTx/Rx burst");
2031         printf("\tRetries (Device Busy)\tAverage IA cycle cost "
2032                         "(assuming 0 retries)");
2033         for (i = 2; i <= 128 ; i *= 2) {
2034                 num_sent = 0;
2035                 num_received = 0;
2036                 retries = 0;
2037                 failed_polls = 0;
2038                 burst_size = i;
2039                 total_cycles = 0;
2040                 while (num_sent < num_to_submit) {
2041                         start_cycles = rte_rdtsc_precise();
2042                         burst_sent = rte_cryptodev_enqueue_burst(dev_num,
2043                                         0, &c_ops[num_sent],
2044                                         ((num_to_submit-num_sent) < burst_size) ?
2045                                         num_to_submit-num_sent : burst_size);
2046                         if (burst_sent == 0)
2047                                 retries++;
2048                         else
2049                                 num_sent += burst_sent;
2050                         end_cycles = rte_rdtsc_precise();
2051                         total_cycles += (end_cycles - start_cycles);
2052                         /*
2053                          * Wait until requests have been sent.
2054                          */
2055                         rte_delay_ms(1);
2056
2057                         start_cycles = rte_rdtsc_precise();
2058                         burst_received = rte_cryptodev_dequeue_burst(
2059                                         dev_num, 0, proc_ops, burst_size);
2060                         if (burst_received == 0)
2061                                 failed_polls++;
2062                         else
2063                                 num_received += burst_received;
2064                         end_cycles = rte_rdtsc_precise();
2065                         total_cycles += end_cycles - start_cycles;
2066                 }
2067
2068                 while (num_received != num_to_submit) {
2069                         if (gbl_driver_id ==
2070                                         rte_cryptodev_driver_id_get(
2071                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
2072                                 rte_cryptodev_enqueue_burst(dev_num, 0,
2073                                                 NULL, 0);
2074
2075                         burst_received = rte_cryptodev_dequeue_burst(
2076                                         dev_num, 0, proc_ops, burst_size);
2077                         if (burst_received == 0)
2078                                 failed_polls++;
2079                         else
2080                                 num_received += burst_received;
2081                 }
2082
2083                 printf("\n%u\t%u\t%u\t\t%u\t\t%u", dev_num, 0,
2084                                         num_sent, num_received, burst_size);
2085                 printf("\t\t%"PRIu64, retries);
2086                 printf("\t\t\t%"PRIu64, total_cycles/num_received);
2087         }
2088         printf("\n");
2089
2090         for (i = 0; i < num_to_submit ; i++) {
2091                 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2092                 rte_crypto_op_free(c_ops[i]);
2093         }
2094         return TEST_SUCCESS;
2095 }
2096
2097 static int
2098 test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams)
2099 {
2100         uint32_t num_to_submit = pparams->total_operations;
2101         struct rte_crypto_op *c_ops[num_to_submit];
2102         struct rte_crypto_op *proc_ops[num_to_submit];
2103         uint64_t failed_polls, retries, start_cycles, end_cycles, total_cycles = 0;
2104         uint32_t burst_sent = 0, burst_received = 0;
2105         uint32_t i, burst_size, num_sent, num_ops_received;
2106         struct crypto_testsuite_params *ts_params = &testsuite_params;
2107         static struct rte_cryptodev_sym_session *sess;
2108
2109         if (rte_cryptodev_count() == 0) {
2110                 printf("\nNo crypto devices found. Is PMD build configured?\n");
2111                 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
2112                 return TEST_FAILED;
2113         }
2114
2115         /* Create Crypto session*/
2116         if (test_perf_create_snow3g_session(ts_params->dev_id,
2117                         pparams->chain, pparams->cipher_algo,
2118                         pparams->key_length, pparams->auth_algo) == 0)
2119                 sess = test_crypto_session;
2120         else
2121                 sess = NULL;
2122         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2123
2124         /* Generate Crypto op data structure(s)*/
2125         for (i = 0; i < num_to_submit ; i++) {
2126                 struct rte_mbuf *m = test_perf_create_pktmbuf(
2127                                                 ts_params->mbuf_mp,
2128                                                 pparams->buf_size);
2129                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2130
2131                 struct rte_crypto_op *op =
2132                                 rte_crypto_op_alloc(ts_params->op_mpool,
2133                                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2134                 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2135
2136                 op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size);
2137                 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2138
2139                 c_ops[i] = op;
2140         }
2141
2142         if (pparams->chain == AEAD)
2143                 printf("\nOn %s dev%u qp%u, %s, aead algo:%s, "
2144                         "Packet Size %u bytes",
2145                         pmd_name(gbl_driver_id),
2146                         ts_params->dev_id, 0,
2147                         chain_mode_name(pparams->chain),
2148                         rte_crypto_aead_algorithm_strings[pparams->aead_algo],
2149                         pparams->buf_size);
2150         else
2151                 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2152                         "Packet Size %u bytes",
2153                         pmd_name(gbl_driver_id),
2154                         ts_params->dev_id, 0,
2155                         chain_mode_name(pparams->chain),
2156                         rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2157                         rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2158                         pparams->buf_size);
2159         printf("\nOps Tx\tOps Rx\tOps/burst  ");
2160         printf("Retries  EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2161
2162         for (i = 2; i <= 128 ; i *= 2) {
2163                 num_sent = 0;
2164                 num_ops_received = 0;
2165                 retries = 0;
2166                 failed_polls = 0;
2167                 burst_size = i;
2168                 total_cycles = 0;
2169                 while (num_sent < num_to_submit) {
2170                         start_cycles = rte_rdtsc_precise();
2171                         burst_sent = rte_cryptodev_enqueue_burst(ts_params->dev_id,
2172                                         0, &c_ops[num_sent],
2173                                         ((num_to_submit-num_sent) < burst_size) ?
2174                                         num_to_submit-num_sent : burst_size);
2175                         end_cycles = rte_rdtsc_precise();
2176                         if (burst_sent == 0)
2177                                 retries++;
2178                         num_sent += burst_sent;
2179                         total_cycles += (end_cycles - start_cycles);
2180
2181                         /* Wait until requests have been sent. */
2182
2183                         rte_delay_ms(1);
2184
2185                         start_cycles = rte_rdtsc_precise();
2186                         burst_received = rte_cryptodev_dequeue_burst(
2187                                         ts_params->dev_id, 0, proc_ops, burst_size);
2188                         end_cycles = rte_rdtsc_precise();
2189                         if (burst_received < burst_sent)
2190                                 failed_polls++;
2191                         num_ops_received += burst_received;
2192
2193                         total_cycles += end_cycles - start_cycles;
2194                 }
2195
2196                 while (num_ops_received != num_to_submit) {
2197                         if (gbl_driver_id ==
2198                                         rte_cryptodev_driver_id_get(
2199                                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)))
2200                                 rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2201                                                 NULL, 0);
2202                         start_cycles = rte_rdtsc_precise();
2203                         burst_received = rte_cryptodev_dequeue_burst(
2204                                         ts_params->dev_id, 0, proc_ops, burst_size);
2205                         end_cycles = rte_rdtsc_precise();
2206                         total_cycles += end_cycles - start_cycles;
2207                         if (burst_received == 0)
2208                                 failed_polls++;
2209                         num_ops_received += burst_received;
2210                 }
2211
2212                 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2213                 printf("\t\t%"PRIu64, retries);
2214                 printf("\t%"PRIu64, failed_polls);
2215                 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2216                 printf("\t\t%"PRIu64, (total_cycles/num_ops_received)*burst_size);
2217                 printf("\t\t%"PRIu64, total_cycles/(num_ops_received*pparams->buf_size));
2218         }
2219         printf("\n");
2220
2221         for (i = 0; i < num_to_submit ; i++) {
2222                 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2223                 rte_crypto_op_free(c_ops[i]);
2224         }
2225
2226         rte_cryptodev_sym_session_clear(ts_params->dev_id,
2227                                 sess);
2228         rte_cryptodev_sym_session_free(sess);
2229
2230         return TEST_SUCCESS;
2231 }
2232
2233 static int
2234 test_perf_snow3G_vary_burst_size(void)
2235 {
2236         unsigned total_operations = 4096;
2237         /*no need to vary pkt size for QAT, should have no effect on IA cycles */
2238         uint16_t buf_lengths[] = {40};
2239         uint8_t i, j;
2240
2241         struct perf_test_params params_set[] = {
2242                         {
2243                                         .chain = CIPHER_ONLY,
2244                                         .cipher_algo  = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
2245                                         .key_length = 16,
2246                                         .auth_algo  = RTE_CRYPTO_AUTH_NULL,
2247                         },
2248                         {
2249                                         .chain = HASH_ONLY,
2250                                         .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
2251                                         .auth_algo  = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
2252                                         .key_length = 16
2253                         },
2254         };
2255
2256         printf("\n\nStart %s.", __func__);
2257         printf("\nThis Test measures the average IA cycle cost using a "
2258                         "constant request(packet) size. ");
2259         printf("Cycle cost is only valid when indicators show device is not busy,"
2260                         " i.e. Retries and EmptyPolls = 0");
2261
2262         for (i = 0; i < RTE_DIM(params_set); i++) {
2263                 printf("\n");
2264                 params_set[i].total_operations = total_operations;
2265
2266                 for (j = 0;
2267                         j < RTE_DIM(buf_lengths);
2268                         j++) {
2269
2270                         params_set[i].buf_size = buf_lengths[j];
2271
2272                         test_perf_snow3G_optimise_cyclecount(&params_set[i]);
2273                 }
2274
2275         }
2276
2277         return 0;
2278 }
2279
2280 static int
2281 test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams)
2282 {
2283         uint32_t num_to_submit = pparams->total_operations;
2284         struct rte_crypto_op *c_ops[num_to_submit];
2285         struct rte_crypto_op *proc_ops[num_to_submit];
2286         uint64_t failed_polls, retries, start_cycles,
2287                 end_cycles, total_cycles = 0;
2288         uint32_t burst_sent = 0, burst_received = 0;
2289         uint32_t i, burst_size, num_sent, num_ops_received;
2290
2291         struct crypto_testsuite_params *ts_params = &testsuite_params;
2292
2293         static struct rte_cryptodev_sym_session *sess;
2294
2295         static struct rte_crypto_op *(*test_perf_set_crypto_op)
2296                         (struct rte_crypto_op *, struct rte_mbuf *,
2297                                         struct rte_cryptodev_sym_session *,
2298                                         unsigned int,
2299                                         enum chain_mode);
2300
2301         if (rte_cryptodev_count() == 0) {
2302                 printf("\nNo crypto devices found. Is PMD build configured?\n");
2303                 return TEST_FAILED;
2304         }
2305
2306         /* Create Crypto session*/
2307         if (test_perf_create_openssl_session(ts_params->dev_id,
2308                         pparams->chain, pparams->cipher_algo,
2309                         pparams->key_length, pparams->auth_algo,
2310                         pparams->aead_algo) == 0)
2311                 sess = test_crypto_session;
2312         else
2313                 sess = NULL;
2314         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
2315
2316         /* Generate Crypto op data structure(s)*/
2317         for (i = 0; i < num_to_submit ; i++) {
2318                 struct rte_mbuf *m = test_perf_create_pktmbuf(
2319                                                 ts_params->mbuf_mp,
2320                                                 pparams->buf_size);
2321                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2322
2323                 struct rte_crypto_op *op =
2324                                 rte_crypto_op_alloc(ts_params->op_mpool,
2325                                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2326                 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2327
2328                 if (pparams->chain == AEAD)
2329                         test_perf_set_crypto_op =
2330                                                 test_perf_set_crypto_op_aes_gcm;
2331                 else {
2332                         switch (pparams->cipher_algo) {
2333                         case RTE_CRYPTO_CIPHER_3DES_CBC:
2334                         case RTE_CRYPTO_CIPHER_3DES_CTR:
2335                                 test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
2336                                 break;
2337                         case RTE_CRYPTO_CIPHER_AES_CBC:
2338                         case RTE_CRYPTO_CIPHER_AES_CTR:
2339                                 test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
2340                                 break;
2341                         default:
2342                                 return TEST_FAILED;
2343                         }
2344                 }
2345
2346                 op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size,
2347                                 pparams->chain);
2348                 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2349
2350                 c_ops[i] = op;
2351         }
2352
2353         if (pparams->chain == AEAD)
2354                 printf("\nOn %s dev%u qp%u, %s, aead_algo:%s, "
2355                         "key length:%u, Packet Size %u bytes",
2356                         pmd_name(gbl_driver_id),
2357                         ts_params->dev_id, 0,
2358                         chain_mode_name(pparams->chain),
2359                         rte_crypto_aead_algorithm_strings[pparams->aead_algo],
2360                         pparams->key_length,
2361                         pparams->buf_size);
2362         else
2363                 printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, "
2364                         "key length:%u, Packet Size %u bytes",
2365                         pmd_name(gbl_driver_id),
2366                         ts_params->dev_id, 0,
2367                         chain_mode_name(pparams->chain),
2368                         rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2369                         rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2370                         pparams->key_length,
2371                         pparams->buf_size);
2372         printf("\nOps Tx\tOps Rx\tOps/burst  ");
2373         printf("Retries  EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t"
2374                         "IACycles/Byte");
2375
2376         for (i = 2; i <= 128 ; i *= 2) {
2377                 num_sent = 0;
2378                 num_ops_received = 0;
2379                 retries = 0;
2380                 failed_polls = 0;
2381                 burst_size = i;
2382                 total_cycles = 0;
2383                 while (num_sent < num_to_submit) {
2384                         start_cycles = rte_rdtsc_precise();
2385                         burst_sent = rte_cryptodev_enqueue_burst(
2386                                         ts_params->dev_id,
2387                                         0, &c_ops[num_sent],
2388                                         ((num_to_submit - num_sent) <
2389                                                 burst_size) ?
2390                                         num_to_submit - num_sent : burst_size);
2391                         end_cycles = rte_rdtsc_precise();
2392                         if (burst_sent == 0)
2393                                 retries++;
2394                         num_sent += burst_sent;
2395                         total_cycles += (end_cycles - start_cycles);
2396
2397                         /* Wait until requests have been sent. */
2398                         rte_delay_ms(1);
2399
2400                         start_cycles = rte_rdtsc_precise();
2401                         burst_received = rte_cryptodev_dequeue_burst(
2402                                         ts_params->dev_id, 0, proc_ops,
2403                                         burst_size);
2404                         end_cycles = rte_rdtsc_precise();
2405                         if (burst_received < burst_sent)
2406                                 failed_polls++;
2407                         num_ops_received += burst_received;
2408
2409                         total_cycles += end_cycles - start_cycles;
2410                 }
2411
2412                 while (num_ops_received != num_to_submit) {
2413                         /* Sending 0 length burst to flush sw crypto device */
2414                         rte_cryptodev_enqueue_burst(ts_params->dev_id, 0,
2415                                         NULL, 0);
2416
2417                         start_cycles = rte_rdtsc_precise();
2418                         burst_received = rte_cryptodev_dequeue_burst(
2419                                         ts_params->dev_id, 0, proc_ops,
2420                                         burst_size);
2421                         end_cycles = rte_rdtsc_precise();
2422
2423                         total_cycles += end_cycles - start_cycles;
2424                         if (burst_received == 0)
2425                                 failed_polls++;
2426                         num_ops_received += burst_received;
2427                 }
2428
2429                 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2430                 printf("\t\t%"PRIu64, retries);
2431                 printf("\t%"PRIu64, failed_polls);
2432                 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2433                 printf("\t\t%"PRIu64, (total_cycles/num_ops_received) *
2434                                 burst_size);
2435                 printf("\t\t%"PRIu64,
2436                                 total_cycles /
2437                                 (num_ops_received * pparams->buf_size));
2438         }
2439         printf("\n");
2440
2441         for (i = 0; i < num_to_submit ; i++) {
2442                 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2443                 rte_crypto_op_free(c_ops[i]);
2444         }
2445
2446         rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
2447         rte_cryptodev_sym_session_free(sess);
2448
2449         return TEST_SUCCESS;
2450 }
2451
2452 static int
2453 test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams)
2454 {
2455         uint32_t num_to_submit = pparams->total_operations;
2456         struct rte_crypto_op *c_ops[num_to_submit];
2457         struct rte_crypto_op *proc_ops[num_to_submit];
2458         uint64_t failed_polls, retries, start_cycles, end_cycles,
2459                  total_cycles = 0;
2460         uint32_t burst_sent = 0, burst_received = 0;
2461         uint32_t i, burst_size, num_sent, num_ops_received;
2462         uint32_t nb_ops;
2463
2464         struct crypto_testsuite_params *ts_params = &testsuite_params;
2465
2466         static struct rte_cryptodev_sym_session *sess;
2467
2468         if (rte_cryptodev_count() == 0) {
2469                 printf("\nNo crypto devices found. Is PMD build configured?\n");
2470                 return TEST_FAILED;
2471         }
2472
2473         /* Create Crypto session*/
2474         if (test_perf_create_armv8_session(ts_params->dev_id,
2475                         pparams->chain, pparams->cipher_algo,
2476                         pparams->key_length, pparams->auth_algo) == 0)
2477                 sess = test_crypto_session;
2478         else
2479                 sess = NULL;
2480
2481         /* Generate Crypto op data structure(s)*/
2482         for (i = 0; i < num_to_submit ; i++) {
2483                 struct rte_mbuf *m = test_perf_create_pktmbuf(
2484                                                 ts_params->mbuf_mp,
2485                                                 pparams->buf_size);
2486                 TEST_ASSERT_NOT_NULL(m, "Failed to allocate tx_buf");
2487
2488                 struct rte_crypto_op *op =
2489                                 rte_crypto_op_alloc(ts_params->op_mpool,
2490                                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
2491                 TEST_ASSERT_NOT_NULL(op, "Failed to allocate op");
2492
2493                 op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size,
2494                                 pparams->chain);
2495                 TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session");
2496
2497                 c_ops[i] = op;
2498         }
2499
2500         printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, "
2501                         "auth_algo:%s, Packet Size %u bytes",
2502                         pmd_name(gbl_driver_id),
2503                         ts_params->dev_id, 0,
2504                         chain_mode_name(pparams->chain),
2505                         rte_crypto_cipher_algorithm_strings[pparams->cipher_algo],
2506                         pparams->key_length,
2507                         rte_crypto_auth_algorithm_strings[pparams->auth_algo],
2508                         pparams->buf_size);
2509         printf("\nOps Tx\tOps Rx\tOps/burst  ");
2510         printf("Retries  "
2511                 "EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte");
2512
2513         for (i = 2; i <= 128 ; i *= 2) {
2514                 num_sent = 0;
2515                 num_ops_received = 0;
2516                 retries = 0;
2517                 failed_polls = 0;
2518                 burst_size = i;
2519                 total_cycles = 0;
2520                 while (num_sent < num_to_submit) {
2521                         if ((num_to_submit - num_sent) < burst_size)
2522                                 nb_ops = num_to_submit - num_sent;
2523                         else
2524                                 nb_ops = burst_size;
2525
2526                         start_cycles = rte_rdtsc();
2527                         burst_sent = rte_cryptodev_enqueue_burst(
2528                                 ts_params->dev_id,
2529                                 0, &c_ops[num_sent],
2530                                 nb_ops);
2531                         end_cycles = rte_rdtsc();
2532
2533                         if (burst_sent == 0)
2534                                 retries++;
2535                         num_sent += burst_sent;
2536                         total_cycles += (end_cycles - start_cycles);
2537
2538                         start_cycles = rte_rdtsc();
2539                         burst_received = rte_cryptodev_dequeue_burst(
2540                                         ts_params->dev_id, 0, proc_ops,
2541                                         burst_size);
2542                         end_cycles = rte_rdtsc();
2543                         if (burst_received < burst_sent)
2544                                 failed_polls++;
2545                         num_ops_received += burst_received;
2546
2547                         total_cycles += end_cycles - start_cycles;
2548                 }
2549
2550                 while (num_ops_received != num_to_submit) {
2551                         /* Sending 0 length burst to flush sw crypto device */
2552                         rte_cryptodev_enqueue_burst(
2553                                                 ts_params->dev_id, 0, NULL, 0);
2554
2555                         start_cycles = rte_rdtsc();
2556                         burst_received = rte_cryptodev_dequeue_burst(
2557                                 ts_params->dev_id, 0, proc_ops, burst_size);
2558                         end_cycles = rte_rdtsc();
2559
2560                         total_cycles += end_cycles - start_cycles;
2561                         if (burst_received == 0)
2562                                 failed_polls++;
2563                         num_ops_received += burst_received;
2564                 }
2565
2566                 printf("\n%u\t%u\t%u", num_sent, num_ops_received, burst_size);
2567                 printf("\t\t%"PRIu64, retries);
2568                 printf("\t%"PRIu64, failed_polls);
2569                 printf("\t\t%"PRIu64, total_cycles/num_ops_received);
2570                 printf("\t\t%"PRIu64,
2571                         (total_cycles/num_ops_received)*burst_size);
2572                 printf("\t\t%"PRIu64,
2573                         total_cycles/(num_ops_received*pparams->buf_size));
2574         }
2575         printf("\n");
2576
2577         for (i = 0; i < num_to_submit ; i++) {
2578                 rte_pktmbuf_free(c_ops[i]->sym->m_src);
2579                 rte_crypto_op_free(c_ops[i]);
2580         }
2581
2582         return TEST_SUCCESS;
2583 }
2584
2585 static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo)
2586 {
2587         switch (algo) {
2588         case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2589                 return 16;
2590         case RTE_CRYPTO_AUTH_SHA1_HMAC:
2591                 return 64;
2592         case RTE_CRYPTO_AUTH_SHA224_HMAC:
2593                 return 64;
2594         case RTE_CRYPTO_AUTH_SHA256_HMAC:
2595                 return 64;
2596         case RTE_CRYPTO_AUTH_SHA384_HMAC:
2597                 return 128;
2598         case RTE_CRYPTO_AUTH_SHA512_HMAC:
2599                 return 128;
2600         default:
2601                 return 0;
2602         }
2603 }
2604
2605 static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo)
2606 {
2607         switch (algo) {
2608         case RTE_CRYPTO_AUTH_SNOW3G_UIA2:
2609                 return 4;
2610         case RTE_CRYPTO_AUTH_SHA1_HMAC:
2611                 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA1;
2612         case RTE_CRYPTO_AUTH_SHA224_HMAC:
2613                 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA224;
2614         case RTE_CRYPTO_AUTH_SHA256_HMAC:
2615                 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA256;
2616         case RTE_CRYPTO_AUTH_SHA384_HMAC:
2617                 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384;
2618         case RTE_CRYPTO_AUTH_SHA512_HMAC:
2619                 return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512;
2620         default:
2621                 return 0;
2622         }
2623 }
2624
2625 static uint32_t get_aead_digest_length(enum rte_crypto_aead_algorithm algo)
2626 {
2627         switch (algo) {
2628         case RTE_CRYPTO_AEAD_AES_GCM:
2629                 return DIGEST_BYTE_LENGTH_AES_GCM;
2630         default:
2631                 return 0;
2632         }
2633 }
2634
2635 static uint8_t aes_key[] = {
2636                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2637                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2638                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2639                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2640 };
2641
2642 static uint8_t aes_iv[] = {
2643                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2644                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2645 };
2646
2647 static uint8_t aes_gcm_aad[] = {
2648                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2649                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2650 };
2651
2652 static uint8_t triple_des_key[] = {
2653                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2654                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2655                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2656 };
2657
2658 static uint8_t triple_des_iv[] = {
2659                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2660 };
2661
2662 static uint8_t hmac_sha_key[] = {
2663                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2664                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2665                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2666                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2667                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2668                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2669                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2670                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2671                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2672                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2673                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2674                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2675                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2676                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2677                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2678                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2679 };
2680
2681 static uint8_t snow3g_cipher_key[] = {
2682                 0x2B, 0xD6, 0x45, 0x9F, 0x82, 0xC5, 0xB3, 0x00,
2683                 0x95, 0x2C, 0x49, 0x10, 0x48, 0x81, 0xFF, 0x48
2684 };
2685
2686 static uint8_t snow3g_iv[] = {
2687                 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00,
2688                 0x72, 0xA4, 0xF2, 0x0F, 0x64, 0x00, 0x00, 0x00
2689 };
2690
2691 static uint8_t snow3g_hash_key[] = {
2692                 0xC7, 0x36, 0xC6, 0xAA, 0xB2, 0x2B, 0xFF, 0xF9,
2693                 0x1E, 0x26, 0x98, 0xD2, 0xE2, 0x2A, 0xD5, 0x7E
2694 };
2695
2696 static int
2697 test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain,
2698                 enum rte_crypto_cipher_algorithm cipher_algo,
2699                 unsigned cipher_key_len,
2700                 enum rte_crypto_auth_algorithm auth_algo)
2701 {
2702         struct crypto_testsuite_params *ts_params = &testsuite_params;
2703         struct rte_crypto_sym_xform cipher_xform = { 0 };
2704         struct rte_crypto_sym_xform auth_xform = { 0 };
2705
2706
2707         /* Setup Cipher Parameters */
2708         cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2709         cipher_xform.cipher.algo = cipher_algo;
2710         cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2711
2712         cipher_xform.cipher.key.data = aes_key;
2713         cipher_xform.cipher.key.length = cipher_key_len;
2714         cipher_xform.cipher.iv.offset = IV_OFFSET;
2715         cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2716         if (chain != CIPHER_ONLY) {
2717                 /* Setup HMAC Parameters */
2718                 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2719                 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2720                 auth_xform.auth.algo = auth_algo;
2721                 auth_xform.auth.key.data = hmac_sha_key;
2722                 auth_xform.auth.key.length = get_auth_key_max_length(auth_algo);
2723                 auth_xform.auth.digest_length =
2724                                         get_auth_digest_length(auth_algo);
2725         }
2726
2727         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2728         switch (chain) {
2729         case CIPHER_HASH:
2730                 cipher_xform.next = &auth_xform;
2731                 auth_xform.next = NULL;
2732                 /* Create Crypto session*/
2733                 return rte_cryptodev_sym_session_init(dev_id,
2734                                 test_crypto_session, &cipher_xform,
2735                                 ts_params->sess_mp);
2736         case HASH_CIPHER:
2737                 auth_xform.next = &cipher_xform;
2738                 cipher_xform.next = NULL;
2739                 /* Create Crypto session*/
2740                 return rte_cryptodev_sym_session_init(dev_id,
2741                                 test_crypto_session, &auth_xform,
2742                                 ts_params->sess_mp);
2743         case CIPHER_ONLY:
2744                 cipher_xform.next = NULL;
2745                 /* Create Crypto session*/
2746                 return rte_cryptodev_sym_session_init(dev_id,
2747                                 test_crypto_session, &cipher_xform,
2748                                 ts_params->sess_mp);
2749         default:
2750                 return -1;
2751         }
2752 }
2753
2754 #define SNOW3G_CIPHER_IV_LENGTH 16
2755
2756 static int
2757 test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain,
2758                 enum rte_crypto_cipher_algorithm cipher_algo, unsigned cipher_key_len,
2759                 enum rte_crypto_auth_algorithm auth_algo)
2760 {
2761         struct crypto_testsuite_params *ts_params = &testsuite_params;
2762         struct rte_crypto_sym_xform cipher_xform = {0};
2763         struct rte_crypto_sym_xform auth_xform = {0};
2764
2765
2766         /* Setup Cipher Parameters */
2767         cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2768         cipher_xform.cipher.algo = cipher_algo;
2769         cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2770
2771         cipher_xform.cipher.key.data = snow3g_cipher_key;
2772         cipher_xform.cipher.key.length = cipher_key_len;
2773         cipher_xform.cipher.iv.offset = IV_OFFSET;
2774         cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2775
2776
2777         /* Setup HMAC Parameters */
2778         auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2779         auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2780         auth_xform.auth.algo = auth_algo;
2781
2782         auth_xform.auth.key.data = snow3g_hash_key;
2783         auth_xform.auth.key.length =  get_auth_key_max_length(auth_algo);
2784         auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2785         /* Auth IV will be after cipher IV */
2786         auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH;
2787         auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH;
2788
2789         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2790         switch (chain) {
2791         case CIPHER_HASH:
2792                 cipher_xform.next = &auth_xform;
2793                 auth_xform.next = NULL;
2794                 /* Create Crypto session*/
2795                 return rte_cryptodev_sym_session_init(dev_id,
2796                                 test_crypto_session, &cipher_xform,
2797                                 ts_params->sess_mp);
2798         case HASH_CIPHER:
2799                 auth_xform.next = &cipher_xform;
2800                 cipher_xform.next = NULL;
2801                 /* Create Crypto session*/
2802                 return rte_cryptodev_sym_session_init(dev_id,
2803                                 test_crypto_session, &auth_xform,
2804                                 ts_params->sess_mp);
2805         case CIPHER_ONLY:
2806                 cipher_xform.next = NULL;
2807                 /* Create Crypto session*/
2808                 return rte_cryptodev_sym_session_init(dev_id,
2809                                 test_crypto_session, &cipher_xform,
2810                                 ts_params->sess_mp);
2811         case HASH_ONLY:
2812                 auth_xform.next = NULL;
2813                 /* Create Crypto session */
2814                 return rte_cryptodev_sym_session_init(dev_id,
2815                                 test_crypto_session, &auth_xform,
2816                                 ts_params->sess_mp);
2817         default:
2818                 return -1;
2819         }
2820 }
2821
2822 static int
2823 test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain,
2824                 enum rte_crypto_cipher_algorithm cipher_algo,
2825                 unsigned int key_len,
2826                 enum rte_crypto_auth_algorithm auth_algo,
2827                 enum rte_crypto_aead_algorithm aead_algo)
2828 {
2829         struct crypto_testsuite_params *ts_params = &testsuite_params;
2830         struct rte_crypto_sym_xform cipher_xform = { 0 };
2831         struct rte_crypto_sym_xform auth_xform = { 0 };
2832         struct rte_crypto_sym_xform aead_xform = { 0 };
2833
2834         if (chain == CIPHER_HASH || chain == HASH_CIPHER) {
2835                 /* Setup Cipher Parameters */
2836                 cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2837                 cipher_xform.cipher.algo = cipher_algo;
2838                 cipher_xform.cipher.iv.offset = IV_OFFSET;
2839                 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2840
2841                 switch (cipher_algo) {
2842                 case RTE_CRYPTO_CIPHER_3DES_CBC:
2843                 case RTE_CRYPTO_CIPHER_3DES_CTR:
2844                         cipher_xform.cipher.key.data = triple_des_key;
2845                         cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH;
2846                         break;
2847                 case RTE_CRYPTO_CIPHER_AES_CBC:
2848                 case RTE_CRYPTO_CIPHER_AES_CTR:
2849                         cipher_xform.cipher.key.data = aes_key;
2850                         cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2851                         break;
2852                 default:
2853                         return -1;
2854                 }
2855
2856                 cipher_xform.cipher.key.length = key_len;
2857
2858                 /* Setup Auth Parameters */
2859                 auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2860                 auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2861                 auth_xform.auth.algo = auth_algo;
2862
2863                 switch (auth_algo) {
2864                 case RTE_CRYPTO_AUTH_SHA1_HMAC:
2865                         auth_xform.auth.key.data = hmac_sha_key;
2866                         break;
2867                 default:
2868                         return -1;
2869                 }
2870
2871                 auth_xform.auth.key.length =  get_auth_key_max_length(auth_algo);
2872                 auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2873         } else if (chain == AEAD) {
2874                 /* Setup AEAD Parameters */
2875                 aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
2876                 aead_xform.aead.op = RTE_CRYPTO_AEAD_OP_ENCRYPT;
2877                 aead_xform.aead.algo = aead_algo;
2878                 aead_xform.aead.iv.offset = IV_OFFSET;
2879
2880                 switch (aead_algo) {
2881                 case RTE_CRYPTO_AEAD_AES_GCM:
2882                         aead_xform.aead.key.data = aes_key;
2883                         aead_xform.aead.iv.length = AES_CIPHER_IV_LENGTH;
2884                         aead_xform.aead.aad_length = AES_GCM_AAD_LENGTH;
2885                         aead_xform.aead.digest_length = get_aead_digest_length(aead_algo);
2886                         break;
2887                 default:
2888                         return -1;
2889                 }
2890
2891                 aead_xform.aead.key.length = key_len;
2892         }
2893
2894         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2895         switch (chain) {
2896         case CIPHER_HASH:
2897                 cipher_xform.next = &auth_xform;
2898                 auth_xform.next = NULL;
2899                 /* Create Crypto session*/
2900                 return rte_cryptodev_sym_session_init(dev_id,
2901                                 test_crypto_session, &cipher_xform,
2902                                 ts_params->sess_mp);
2903         case HASH_CIPHER:
2904                 auth_xform.next = &cipher_xform;
2905                 cipher_xform.next = NULL;
2906                 /* Create Crypto session*/
2907                 return rte_cryptodev_sym_session_init(dev_id,
2908                                 test_crypto_session, &auth_xform,
2909                                 ts_params->sess_mp);
2910         case AEAD:
2911                 /* Create Crypto session*/
2912                 return rte_cryptodev_sym_session_init(dev_id,
2913                                 test_crypto_session, &aead_xform,
2914                                 ts_params->sess_mp);
2915         default:
2916                 return -1;
2917         }
2918 }
2919
2920 static int
2921 test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain,
2922                 enum rte_crypto_cipher_algorithm cipher_algo,
2923                 unsigned int cipher_key_len,
2924                 enum rte_crypto_auth_algorithm auth_algo)
2925 {
2926         struct crypto_testsuite_params *ts_params = &testsuite_params;
2927         struct rte_crypto_sym_xform cipher_xform = { 0 };
2928         struct rte_crypto_sym_xform auth_xform = { 0 };
2929
2930         /* Setup Cipher Parameters */
2931         cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
2932         cipher_xform.cipher.algo = cipher_algo;
2933
2934         switch (cipher_algo) {
2935         case RTE_CRYPTO_CIPHER_AES_CBC:
2936                 cipher_xform.cipher.key.data = aes_cbc_128_key;
2937                 break;
2938         default:
2939                 return -1;
2940         }
2941
2942         cipher_xform.cipher.key.length = cipher_key_len;
2943         cipher_xform.cipher.iv.offset = IV_OFFSET;
2944         cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH;
2945
2946         /* Setup Auth Parameters */
2947         auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
2948         auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE;
2949         auth_xform.auth.algo = auth_algo;
2950
2951         auth_xform.auth.digest_length = get_auth_digest_length(auth_algo);
2952
2953         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
2954
2955         switch (chain) {
2956         case CIPHER_HASH:
2957                 cipher_xform.next = &auth_xform;
2958                 auth_xform.next = NULL;
2959                 /* Encrypt and hash the result */
2960                 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
2961                 /* Create Crypto session*/
2962                 return rte_cryptodev_sym_session_init(dev_id,
2963                                 test_crypto_session, &cipher_xform,
2964                                 ts_params->sess_mp);
2965         case HASH_CIPHER:
2966                 auth_xform.next = &cipher_xform;
2967                 cipher_xform.next = NULL;
2968                 /* Hash encrypted message and decrypt */
2969                 cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT;
2970                 /* Create Crypto session*/
2971                 return rte_cryptodev_sym_session_init(dev_id,
2972                                 test_crypto_session, &auth_xform,
2973                                 ts_params->sess_mp);
2974         default:
2975                 return -1;
2976         }
2977 }
2978
2979 static struct rte_mbuf *
2980 test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz)
2981 {
2982         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
2983
2984         if (rte_pktmbuf_append(m, buf_sz) == NULL) {
2985                 rte_pktmbuf_free(m);
2986                 return NULL;
2987         }
2988
2989         memset(rte_pktmbuf_mtod(m, uint8_t *), 0, buf_sz);
2990
2991         return m;
2992 }
2993
2994 static inline struct rte_crypto_op *
2995 test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m,
2996                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
2997                 enum chain_mode chain)
2998 {
2999         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3000                 rte_crypto_op_free(op);
3001                 return NULL;
3002         }
3003
3004         /* Authentication Parameters */
3005         if (chain == CIPHER_ONLY) {
3006                 op->sym->auth.digest.data = NULL;
3007                 op->sym->auth.digest.phys_addr = 0;
3008                 op->sym->auth.data.offset = 0;
3009                 op->sym->auth.data.length = 0;
3010         } else {
3011                 op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m,
3012                                  uint8_t *, data_len);
3013                 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m,
3014                                 data_len);
3015                 op->sym->auth.data.offset = 0;
3016                 op->sym->auth.data.length = data_len;
3017         }
3018
3019
3020         /* Copy the IV at the end of the crypto operation */
3021         rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3022                         aes_iv, AES_CIPHER_IV_LENGTH);
3023
3024         /* Cipher Parameters */
3025         op->sym->cipher.data.offset = 0;
3026         op->sym->cipher.data.length = data_len;
3027
3028         op->sym->m_src = m;
3029
3030         return op;
3031 }
3032
3033 static inline struct rte_crypto_op *
3034 test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m,
3035                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3036                 enum chain_mode chain __rte_unused)
3037 {
3038         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3039                 rte_crypto_op_free(op);
3040                 return NULL;
3041         }
3042
3043         /* Authentication Parameters */
3044         op->sym->aead.digest.data = (uint8_t *)m->buf_addr +
3045                                         (m->data_off + data_len);
3046         op->sym->aead.digest.phys_addr =
3047                                 rte_pktmbuf_mtophys_offset(m, data_len);
3048         op->sym->aead.aad.data = aes_gcm_aad;
3049
3050         /* Copy IV at the end of the crypto operation */
3051         rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3052                         aes_iv, AES_CIPHER_IV_LENGTH);
3053
3054         /* Data lengths/offsets Parameters */
3055         op->sym->aead.data.offset = 0;
3056         op->sym->aead.data.length = data_len;
3057
3058         op->sym->m_src = m;
3059
3060         return op;
3061 }
3062
3063 static inline struct rte_crypto_op *
3064 test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m,
3065                 struct rte_cryptodev_sym_session *sess, unsigned int data_len)
3066 {
3067         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3068                         uint8_t *, IV_OFFSET);
3069
3070         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3071                 rte_crypto_op_free(op);
3072                 return NULL;
3073         }
3074
3075         rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3076
3077         /* Authentication Parameters */
3078         op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3079                                                 (m->data_off + data_len);
3080         op->sym->auth.digest.phys_addr =
3081                                 rte_pktmbuf_mtophys_offset(m, data_len);
3082
3083         /* Data lengths/offsets Parameters */
3084         op->sym->auth.data.offset = 0;
3085         op->sym->auth.data.length = data_len << 3;
3086
3087         op->sym->cipher.data.offset = 0;
3088         op->sym->cipher.data.length = data_len << 3;
3089
3090         op->sym->m_src = m;
3091
3092         return op;
3093 }
3094
3095 static inline struct rte_crypto_op *
3096 test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op,
3097                 struct rte_mbuf *m,
3098                 struct rte_cryptodev_sym_session *sess,
3099                 unsigned data_len)
3100 {
3101         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3102                 rte_crypto_op_free(op);
3103                 return NULL;
3104         }
3105
3106         /* Copy IV at the end of the crypto operation */
3107         rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3108                         snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3109
3110         /* Cipher Parameters */
3111         op->sym->cipher.data.offset = 0;
3112         op->sym->cipher.data.length = data_len << 3;
3113
3114         rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3115                         snow3g_iv,
3116                         SNOW3G_CIPHER_IV_LENGTH);
3117
3118         op->sym->m_src = m;
3119
3120         return op;
3121 }
3122
3123
3124 static inline struct rte_crypto_op *
3125 test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op,
3126                 struct rte_mbuf *m,
3127                 struct rte_cryptodev_sym_session *sess,
3128                 unsigned int data_len)
3129 {
3130         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
3131                         uint8_t *, IV_OFFSET);
3132
3133         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3134                 rte_crypto_op_free(op);
3135                 return NULL;
3136         }
3137
3138         rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH);
3139
3140         /* Authentication Parameters */
3141
3142         op->sym->auth.digest.data =
3143                         (uint8_t *)rte_pktmbuf_mtod_offset(m, uint8_t *,
3144                         data_len);
3145         op->sym->auth.digest.phys_addr =
3146                                 rte_pktmbuf_mtophys_offset(m, data_len +
3147                                         SNOW3G_CIPHER_IV_LENGTH);
3148
3149         /* Data lengths/offsets Parameters */
3150         op->sym->auth.data.offset = 0;
3151         op->sym->auth.data.length = data_len << 3;
3152
3153         op->sym->m_src = m;
3154
3155         return op;
3156 }
3157
3158
3159 static inline struct rte_crypto_op *
3160 test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m,
3161                 struct rte_cryptodev_sym_session *sess, unsigned int data_len,
3162                 enum chain_mode chain __rte_unused)
3163 {
3164         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
3165                 rte_crypto_op_free(op);
3166                 return NULL;
3167         }
3168
3169         /* Authentication Parameters */
3170         op->sym->auth.digest.data = (uint8_t *)m->buf_addr +
3171                                         (m->data_off + data_len);
3172         op->sym->auth.digest.phys_addr =
3173                                 rte_pktmbuf_mtophys_offset(m, data_len);
3174
3175         /* Copy IV at the end of the crypto operation */
3176         rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
3177                         triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH);
3178
3179         /* Data lengths/offsets Parameters */
3180         op->sym->auth.data.offset = 0;
3181         op->sym->auth.data.length = data_len;
3182
3183         op->sym->cipher.data.offset = 0;
3184         op->sym->cipher.data.length = data_len;
3185
3186         op->sym->m_src = m;
3187
3188         return op;
3189 }
3190
3191 /* An mbuf set is used in each burst. An mbuf can be used by multiple bursts at
3192  * same time, i.e. as they're not dereferenced there's no need to wait until
3193  * finished with to re-use */
3194 #define NUM_MBUF_SETS 8
3195
3196 static int
3197 test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id,
3198                 struct perf_test_params *pparams)
3199 {
3200         uint16_t i, k, l, m;
3201         uint16_t j = 0;
3202         uint16_t ops_unused = 0;
3203
3204         uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3205         uint64_t processed = 0, failed_polls = 0, retries = 0;
3206         uint64_t tsc_start = 0, tsc_end = 0;
3207
3208         uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3209
3210         struct rte_crypto_op *ops[pparams->burst_size];
3211         struct rte_crypto_op *proc_ops[pparams->burst_size];
3212
3213         struct rte_mbuf *mbufs[pparams->burst_size * 8];
3214
3215         struct crypto_testsuite_params *ts_params = &testsuite_params;
3216
3217         static struct rte_cryptodev_sym_session *sess;
3218
3219         if (rte_cryptodev_count() == 0) {
3220                 printf("\nNo crypto devices available. Is kernel driver loaded?\n");
3221                 return TEST_FAILED;
3222         }
3223
3224         /* Create Crypto session*/
3225         if (test_perf_create_aes_sha_session(ts_params->dev_id,
3226                         pparams->chain, pparams->cipher_algo,
3227                         pparams->key_length, pparams->auth_algo) == 0)
3228                 sess = test_crypto_session;
3229         else
3230                 sess = NULL;
3231         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3232
3233         /* Generate a burst of crypto operations */
3234         for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3235                 mbufs[i] = test_perf_create_pktmbuf(
3236                                 ts_params->mbuf_mp,
3237                                 pparams->buf_size);
3238
3239                 if (mbufs[i] == NULL) {
3240                         printf("\nFailed to get mbuf - freeing the rest.\n");
3241                         for (k = 0; k < i; k++)
3242                                 rte_pktmbuf_free(mbufs[k]);
3243                         return -1;
3244                 }
3245
3246                 /* Make room for Digest in mbuf */
3247                 if (pparams->chain != CIPHER_ONLY)
3248                         rte_pktmbuf_append(mbufs[i], digest_length);
3249         }
3250
3251
3252         tsc_start = rte_rdtsc_precise();
3253
3254         while (total_enqueued < pparams->total_operations) {
3255                 uint16_t burst_size =
3256                 total_enqueued+pparams->burst_size <= pparams->total_operations ?
3257                 pparams->burst_size : pparams->total_operations-total_enqueued;
3258                 uint16_t ops_needed = burst_size-ops_unused;
3259
3260                 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3261                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3262                         printf("\nFailed to alloc enough ops, finish dequeuing "
3263                                 "and free ops below.");
3264                 } else {
3265                         for (i = 0; i < ops_needed; i++)
3266                                 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3267                                         mbufs[i + (pparams->burst_size *
3268                                                 (j % NUM_MBUF_SETS))],
3269                                         sess, pparams->buf_size,
3270                                         pparams->chain);
3271
3272                         /* enqueue burst */
3273                         burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3274                                         queue_id, ops, burst_size);
3275
3276                         if (burst_enqueued < burst_size)
3277                                 retries++;
3278
3279                         ops_unused = burst_size-burst_enqueued;
3280                         total_enqueued += burst_enqueued;
3281                 }
3282
3283                 /* dequeue burst */
3284                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3285                                 proc_ops, pparams->burst_size);
3286                 if (burst_dequeued == 0)
3287                         failed_polls++;
3288                 else {
3289                         processed += burst_dequeued;
3290
3291                         for (l = 0; l < burst_dequeued; l++)
3292                                 rte_crypto_op_free(proc_ops[l]);
3293                 }
3294                 j++;
3295         }
3296
3297         /* Dequeue any operations still in the crypto device */
3298         while (processed < pparams->total_operations) {
3299                 /* Sending 0 length burst to flush sw crypto device */
3300                 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3301
3302                 /* dequeue burst */
3303                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3304                                 proc_ops, pparams->burst_size);
3305                 if (burst_dequeued == 0)
3306                         failed_polls++;
3307                 else {
3308                         processed += burst_dequeued;
3309
3310                         for (m = 0; m < burst_dequeued; m++)
3311                                 rte_crypto_op_free(proc_ops[m]);
3312                 }
3313         }
3314
3315         tsc_end = rte_rdtsc_precise();
3316
3317         double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3318         double throughput = (ops_s * pparams->buf_size * 8) / 1000000000;
3319
3320         printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size, ops_s/1000000,
3321                         throughput, retries, failed_polls);
3322
3323         for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3324                 rte_pktmbuf_free(mbufs[i]);
3325
3326         rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3327         rte_cryptodev_sym_session_free(sess);
3328
3329         printf("\n");
3330         return TEST_SUCCESS;
3331 }
3332
3333
3334 static int
3335 test_perf_snow3g(uint8_t dev_id, uint16_t queue_id,
3336                 struct perf_test_params *pparams)
3337 {
3338         uint16_t i, k, l, m;
3339         uint16_t j = 0;
3340         uint16_t ops_unused = 0;
3341         uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3342         uint64_t processed = 0, failed_polls = 0, retries = 0;
3343         uint64_t tsc_start = 0, tsc_end = 0;
3344
3345         uint16_t digest_length = get_auth_digest_length(pparams->auth_algo);
3346
3347         struct rte_crypto_op *ops[pparams->burst_size];
3348         struct rte_crypto_op *proc_ops[pparams->burst_size];
3349
3350         struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3351
3352         struct crypto_testsuite_params *ts_params = &testsuite_params;
3353
3354         static struct rte_cryptodev_sym_session *sess;
3355
3356         if (rte_cryptodev_count() == 0) {
3357                 printf("\nNo crypto devices found. Is PMD build configured?\n");
3358                 printf("\nAnd is kernel driver loaded for HW PMDs?\n");
3359                 return TEST_FAILED;
3360         }
3361
3362         /* Create Crypto session*/
3363         if (test_perf_create_snow3g_session(ts_params->dev_id,
3364                         pparams->chain, pparams->cipher_algo,
3365                         pparams->key_length, pparams->auth_algo) == 0)
3366                 sess = test_crypto_session;
3367         else
3368                 sess = NULL;
3369         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3370
3371         /* Generate a burst of crypto operations */
3372         for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3373                 /*
3374                  * Buffer size is allocated, for perf tests they
3375                  * are equal + digest len.
3376                  */
3377                 mbufs[i] = test_perf_create_pktmbuf(
3378                                 ts_params->mbuf_mp,
3379                                 pparams->buf_size  +
3380                                 digest_length);
3381
3382                 if (mbufs[i] == NULL) {
3383                         printf("\nFailed to get mbuf - freeing the rest.\n");
3384                         for (k = 0; k < i; k++)
3385                                 rte_pktmbuf_free(mbufs[k]);
3386                         return -1;
3387                 }
3388
3389         }
3390
3391         tsc_start = rte_rdtsc_precise();
3392
3393         while (total_enqueued < pparams->total_operations) {
3394                 uint16_t burst_size =
3395                                 (total_enqueued+pparams->burst_size)
3396                                                 <= pparams->total_operations ?
3397                 pparams->burst_size : pparams->total_operations-total_enqueued;
3398                 uint16_t ops_needed = burst_size-ops_unused;
3399                 /* Handle the last burst correctly */
3400                 uint16_t op_offset = pparams->burst_size - burst_size;
3401
3402                 if (ops_needed !=
3403                         rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3404                                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
3405                                                 ops+op_offset, ops_needed)) {
3406                         printf("\nFailed to alloc enough ops.");
3407                         /*Don't exit, dequeue, more ops should become available*/
3408                 } else {
3409                         for (i = 0; i < ops_needed; i++) {
3410                                 if (pparams->chain == HASH_ONLY)
3411                                         ops[i+op_offset] =
3412                                         test_perf_set_crypto_op_snow3g_hash(ops[i+op_offset],
3413                                         mbufs[i +
3414                                           (pparams->burst_size * (j % NUM_MBUF_SETS))],
3415                                         sess,
3416                                         pparams->buf_size);
3417                                 else if (pparams->chain == CIPHER_ONLY)
3418                                         ops[i+op_offset] =
3419                                         test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset],
3420                                         mbufs[i +
3421                                           (pparams->burst_size * (j % NUM_MBUF_SETS))],
3422                                         sess,
3423                                         pparams->buf_size);
3424                                 else
3425                                         return 1;
3426                         }
3427
3428                         /* enqueue burst */
3429                         burst_enqueued =
3430                                 rte_cryptodev_enqueue_burst(dev_id, queue_id,
3431                                                 ops+op_offset, burst_size);
3432
3433                         if (burst_enqueued < burst_size)
3434                                 retries++;
3435
3436                         ops_unused = burst_size-burst_enqueued;
3437                         total_enqueued += burst_enqueued;
3438                 }
3439
3440                 /* dequeue burst */
3441                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3442                                         proc_ops, pparams->burst_size);
3443                 if (burst_dequeued == 0) {
3444                         failed_polls++;
3445                 } else {
3446                         processed += burst_dequeued;
3447                         for (l = 0; l < burst_dequeued; l++)
3448                                 rte_crypto_op_free(proc_ops[l]);
3449                 }
3450                 j++;
3451         }
3452
3453         /* Dequeue any operations still in the crypto device */
3454         while (processed < pparams->total_operations) {
3455                 /* Sending 0 length burst to flush sw crypto device */
3456                 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3457
3458                 /* dequeue burst */
3459                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3460                                 proc_ops, pparams->burst_size);
3461                 if (burst_dequeued == 0)
3462                         failed_polls++;
3463                 else {
3464                         processed += burst_dequeued;
3465                         for (m = 0; m < burst_dequeued; m++)
3466                                 rte_crypto_op_free(proc_ops[m]);
3467                 }
3468         }
3469
3470         tsc_end = rte_rdtsc_precise();
3471
3472         double ops_s = ((double)processed / (tsc_end - tsc_start)) * rte_get_tsc_hz();
3473         double cycles_burst = (double) (tsc_end - tsc_start) /
3474                                         (double) processed * pparams->burst_size;
3475         double cycles_buff = (double) (tsc_end - tsc_start) / (double) processed;
3476         double cycles_B = cycles_buff / pparams->buf_size;
3477         double throughput = (ops_s * pparams->buf_size * 8) / 1000000;
3478
3479         if (gbl_driver_id == rte_cryptodev_driver_id_get(
3480                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD))) {
3481                 /* Cycle count misleading on HW devices for this test, so don't print */
3482                 printf("%4u\t%6.2f\t%10.2f\t n/a \t\t n/a "
3483                         "\t\t n/a \t\t%8"PRIu64"\t%8"PRIu64,
3484                         pparams->buf_size, ops_s/1000000,
3485                         throughput, retries, failed_polls);
3486         } else {
3487                 printf("%4u\t%6.2f\t%10.2f\t%10.2f\t%8.2f"
3488                         "\t%8.2f\t%8"PRIu64"\t%8"PRIu64,
3489                         pparams->buf_size, ops_s/1000000, throughput, cycles_burst,
3490                         cycles_buff, cycles_B, retries, failed_polls);
3491         }
3492
3493         for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3494                 rte_pktmbuf_free(mbufs[i]);
3495
3496         rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3497         rte_cryptodev_sym_session_free(sess);
3498
3499         printf("\n");
3500         return TEST_SUCCESS;
3501 }
3502
3503 static int
3504 test_perf_openssl(uint8_t dev_id, uint16_t queue_id,
3505                 struct perf_test_params *pparams)
3506 {
3507         uint16_t i, k, l, m;
3508         uint16_t j = 0;
3509         uint16_t ops_unused = 0;
3510
3511         uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3512         uint64_t processed = 0, failed_polls = 0, retries = 0;
3513         uint64_t tsc_start = 0, tsc_end = 0;
3514
3515         struct rte_crypto_op *ops[pparams->burst_size];
3516         struct rte_crypto_op *proc_ops[pparams->burst_size];
3517
3518         struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3519
3520         struct crypto_testsuite_params *ts_params = &testsuite_params;
3521
3522         static struct rte_cryptodev_sym_session *sess;
3523
3524         static struct rte_crypto_op *(*test_perf_set_crypto_op)
3525                         (struct rte_crypto_op *, struct rte_mbuf *,
3526                                         struct rte_cryptodev_sym_session *,
3527                                         unsigned int,
3528                                         enum chain_mode);
3529
3530         if (pparams->chain == AEAD)
3531                 test_perf_set_crypto_op =
3532                                         test_perf_set_crypto_op_aes_gcm;
3533         else {
3534                 switch (pparams->cipher_algo) {
3535                 case RTE_CRYPTO_CIPHER_3DES_CBC:
3536                 case RTE_CRYPTO_CIPHER_3DES_CTR:
3537                         test_perf_set_crypto_op = test_perf_set_crypto_op_3des;
3538                         break;
3539                 case RTE_CRYPTO_CIPHER_AES_CBC:
3540                 case RTE_CRYPTO_CIPHER_AES_CTR:
3541                         test_perf_set_crypto_op = test_perf_set_crypto_op_aes;
3542                         break;
3543                 default:
3544                         return TEST_FAILED;
3545                 }
3546         }
3547
3548         if (rte_cryptodev_count() == 0) {
3549                 printf("\nNo crypto devices found. Is PMD build configured?\n");
3550                 return TEST_FAILED;
3551         }
3552
3553         /* Create Crypto session*/
3554         if (test_perf_create_openssl_session(ts_params->dev_id,
3555                         pparams->chain, pparams->cipher_algo,
3556                         pparams->key_length, pparams->auth_algo,
3557                         pparams->aead_algo) == 0)
3558                 sess = test_crypto_session;
3559         else
3560                 sess = NULL;
3561         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3562
3563         /* Generate a burst of crypto operations */
3564         for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3565                 mbufs[i] = test_perf_create_pktmbuf(
3566                                 ts_params->mbuf_mp,
3567                                 pparams->buf_size);
3568
3569                 if (mbufs[i] == NULL) {
3570                         printf("\nFailed to get mbuf - freeing the rest.\n");
3571                         for (k = 0; k < i; k++)
3572                                 rte_pktmbuf_free(mbufs[k]);
3573                         return -1;
3574                 }
3575         }
3576
3577         tsc_start = rte_rdtsc_precise();
3578
3579         while (total_enqueued < pparams->total_operations) {
3580                 uint16_t burst_size =
3581                 total_enqueued + pparams->burst_size <=
3582                 pparams->total_operations ? pparams->burst_size :
3583                                 pparams->total_operations - total_enqueued;
3584                 uint16_t ops_needed = burst_size - ops_unused;
3585
3586                 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3587                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3588                         printf("\nFailed to alloc enough ops, finish dequeuing "
3589                                 "and free ops below.");
3590                 } else {
3591                         for (i = 0; i < ops_needed; i++)
3592                                 ops[i] = test_perf_set_crypto_op(ops[i],
3593                                         mbufs[i + (pparams->burst_size *
3594                                                 (j % NUM_MBUF_SETS))],
3595                                         sess, pparams->buf_size,
3596                                         pparams->chain);
3597
3598                         /* enqueue burst */
3599                         burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3600                                         queue_id, ops, burst_size);
3601
3602                         if (burst_enqueued < burst_size)
3603                                 retries++;
3604
3605                         ops_unused = burst_size - burst_enqueued;
3606                         total_enqueued += burst_enqueued;
3607                 }
3608
3609                 /* dequeue burst */
3610                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3611                                 proc_ops, pparams->burst_size);
3612                 if (burst_dequeued == 0)
3613                         failed_polls++;
3614                 else {
3615                         processed += burst_dequeued;
3616
3617                         for (l = 0; l < burst_dequeued; l++)
3618                                 rte_crypto_op_free(proc_ops[l]);
3619                 }
3620                 j++;
3621         }
3622
3623         /* Dequeue any operations still in the crypto device */
3624         while (processed < pparams->total_operations) {
3625                 /* Sending 0 length burst to flush sw crypto device */
3626                 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3627
3628                 /* dequeue burst */
3629                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3630                                 proc_ops, pparams->burst_size);
3631                 if (burst_dequeued == 0)
3632                         failed_polls++;
3633                 else {
3634                         processed += burst_dequeued;
3635
3636                         for (m = 0; m < burst_dequeued; m++)
3637                                 rte_crypto_op_free(proc_ops[m]);
3638                 }
3639         }
3640
3641         tsc_end = rte_rdtsc_precise();
3642
3643         double ops_s = ((double)processed / (tsc_end - tsc_start))
3644                                         * rte_get_tsc_hz();
3645         double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3646                                         / 1000000000;
3647
3648         printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3649                         ops_s / 1000000, throughput, retries, failed_polls);
3650
3651         for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3652                 rte_pktmbuf_free(mbufs[i]);
3653
3654         rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
3655         rte_cryptodev_sym_session_free(sess);
3656
3657         printf("\n");
3658         return TEST_SUCCESS;
3659 }
3660
3661 static int
3662 test_perf_armv8(uint8_t dev_id, uint16_t queue_id,
3663                 struct perf_test_params *pparams)
3664 {
3665         uint16_t i, k, l, m;
3666         uint16_t j = 0;
3667         uint16_t ops_unused = 0;
3668         uint16_t burst_size;
3669         uint16_t ops_needed;
3670
3671         uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
3672         uint64_t processed = 0, failed_polls = 0, retries = 0;
3673         uint64_t tsc_start = 0, tsc_end = 0;
3674
3675         struct rte_crypto_op *ops[pparams->burst_size];
3676         struct rte_crypto_op *proc_ops[pparams->burst_size];
3677
3678         struct rte_mbuf *mbufs[pparams->burst_size * NUM_MBUF_SETS];
3679
3680         struct crypto_testsuite_params *ts_params = &testsuite_params;
3681
3682         static struct rte_cryptodev_sym_session *sess;
3683
3684         if (rte_cryptodev_count() == 0) {
3685                 printf("\nNo crypto devices found. Is PMD build configured?\n");
3686                 return TEST_FAILED;
3687         }
3688
3689         /* Create Crypto session*/
3690         if (test_perf_create_armv8_session(ts_params->dev_id,
3691                         pparams->chain, pparams->cipher_algo,
3692                         pparams->key_length, pparams->auth_algo) == 0)
3693                 sess = test_crypto_session;
3694         else
3695                 sess = NULL;
3696         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
3697
3698         /* Generate a burst of crypto operations */
3699         for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) {
3700                 mbufs[i] = test_perf_create_pktmbuf(
3701                                 ts_params->mbuf_mp,
3702                                 pparams->buf_size);
3703
3704                 if (mbufs[i] == NULL) {
3705                         printf("\nFailed to get mbuf - freeing the rest.\n");
3706                         for (k = 0; k < i; k++)
3707                                 rte_pktmbuf_free(mbufs[k]);
3708                         return -1;
3709                 }
3710         }
3711
3712         tsc_start = rte_rdtsc();
3713
3714         while (total_enqueued < pparams->total_operations) {
3715                 if ((total_enqueued + pparams->burst_size) <=
3716                                         pparams->total_operations)
3717                         burst_size = pparams->burst_size;
3718                 else
3719                         burst_size = pparams->total_operations - total_enqueued;
3720
3721                 ops_needed = burst_size - ops_unused;
3722
3723                 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
3724                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
3725                         printf("\nFailed to alloc enough ops, finish dequeuing "
3726                                 "and free ops below.");
3727                 } else {
3728                         for (i = 0; i < ops_needed; i++)
3729                                 ops[i] = test_perf_set_crypto_op_aes(ops[i],
3730                                         mbufs[i + (pparams->burst_size *
3731                                                 (j % NUM_MBUF_SETS))], sess,
3732                                         pparams->buf_size,
3733                                         pparams->chain);
3734
3735                         /* enqueue burst */
3736                         burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
3737                                         queue_id, ops, burst_size);
3738
3739                         if (burst_enqueued < burst_size)
3740                                 retries++;
3741
3742                         ops_unused = burst_size - burst_enqueued;
3743                         total_enqueued += burst_enqueued;
3744                 }
3745
3746                 /* dequeue burst */
3747                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3748                                 proc_ops, pparams->burst_size);
3749                 if (burst_dequeued == 0)
3750                         failed_polls++;
3751                 else {
3752                         processed += burst_dequeued;
3753
3754                         for (l = 0; l < burst_dequeued; l++)
3755                                 rte_crypto_op_free(proc_ops[l]);
3756                 }
3757                 j++;
3758         }
3759
3760         /* Dequeue any operations still in the crypto device */
3761         while (processed < pparams->total_operations) {
3762                 /* Sending 0 length burst to flush sw crypto device */
3763                 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
3764
3765                 /* dequeue burst */
3766                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
3767                                 proc_ops, pparams->burst_size);
3768                 if (burst_dequeued == 0)
3769                         failed_polls++;
3770                 else {
3771                         processed += burst_dequeued;
3772
3773                         for (m = 0; m < burst_dequeued; m++)
3774                                 rte_crypto_op_free(proc_ops[m]);
3775                 }
3776         }
3777
3778         tsc_end = rte_rdtsc();
3779
3780         double ops_s = ((double)processed / (tsc_end - tsc_start))
3781                                         * rte_get_tsc_hz();
3782         double throughput = (ops_s * pparams->buf_size * NUM_MBUF_SETS)
3783                                         / 1000000000;
3784
3785         printf("\t%u\t%6.2f\t%10.2f\t%8"PRIu64"\t%8"PRIu64, pparams->buf_size,
3786                         ops_s / 1000000, throughput, retries, failed_polls);
3787
3788         for (i = 0; i < pparams->burst_size * NUM_MBUF_SETS; i++)
3789                 rte_pktmbuf_free(mbufs[i]);
3790
3791         printf("\n");
3792         return TEST_SUCCESS;
3793 }
3794
3795 /*
3796
3797     perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA1);
3798     perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_256);
3799     perf_test_aes_sha("avx2", HASH_CIPHER, 16, CBC, SHA_512);
3800
3801     perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA1);
3802     perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_256);
3803     perf_test_aes_sha("avx2", CIPHER_HASH, 32, CBC, SHA_512);
3804
3805     perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA1);
3806     perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_256);
3807     perf_test_aes_sha("avx2", HASH_CIPHER, 32, CBC, SHA_512);
3808  */
3809 static int
3810 test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void)
3811 {
3812         unsigned total_operations = 1000000;
3813         unsigned burst_size = 32;
3814         unsigned buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536, 1792, 2048 };
3815         uint8_t i, j;
3816
3817         struct perf_test_params params_set[] = {
3818                 {
3819                         .chain = CIPHER_ONLY,
3820                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3821                         .key_length = 16,
3822                         .auth_algo = RTE_CRYPTO_AUTH_NULL
3823                 },
3824                 {
3825                         .chain = CIPHER_HASH,
3826                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3827                         .key_length = 16,
3828                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3829                 },
3830                 {
3831                         .chain = CIPHER_HASH,
3832
3833                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3834                         .key_length = 16,
3835                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3836                 },
3837                 {
3838                         .chain = CIPHER_HASH,
3839
3840                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3841                         .key_length = 16,
3842                         .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3843                 },
3844                 {
3845                         .chain = CIPHER_HASH,
3846
3847                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3848                         .key_length = 32,
3849                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3850                 },
3851                 {
3852                         .chain = CIPHER_HASH,
3853
3854                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3855                         .key_length = 32,
3856                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
3857                 },
3858                 {
3859                         .chain = CIPHER_HASH,
3860
3861                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
3862                         .key_length = 32,
3863                         .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC
3864                 },
3865         };
3866
3867         for (i = 0; i < RTE_DIM(params_set); i++) {
3868
3869                 params_set[i].total_operations = total_operations;
3870                 params_set[i].burst_size = burst_size;
3871                 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
3872                         " burst_size: %d ops\n",
3873                         chain_mode_name(params_set[i].chain),
3874                         rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
3875                         rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
3876                         params_set[i].key_length,
3877                         burst_size);
3878                 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
3879                         "Retries\tEmptyPolls\n");
3880                 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3881                         params_set[i].buf_size = buf_lengths[j];
3882                         test_perf_aes_sha(testsuite_params.dev_id, 0,
3883                                         &params_set[i]);
3884                 }
3885         }
3886         return 0;
3887 }
3888
3889 static int
3890 test_perf_snow3G_vary_pkt_size(void)
3891 {
3892         unsigned total_operations = 1000000;
3893         uint8_t i, j;
3894         unsigned k;
3895         uint16_t burst_sizes[] = { 64 };
3896         uint16_t buf_lengths[] = { 40, 64, 80, 120, 240, 256, 400, 512, 600, 1024, 2048 };
3897
3898         struct perf_test_params params_set[] = {
3899                 {
3900                         .chain = CIPHER_ONLY,
3901                         .cipher_algo  = RTE_CRYPTO_CIPHER_SNOW3G_UEA2,
3902                         .key_length = 16,
3903                         .auth_algo  = RTE_CRYPTO_AUTH_NULL,
3904                 },
3905                 {
3906                         .chain = HASH_ONLY,
3907                         .cipher_algo = RTE_CRYPTO_CIPHER_NULL,
3908                         .auth_algo  = RTE_CRYPTO_AUTH_SNOW3G_UIA2,
3909                         .key_length = 16
3910                 },
3911         };
3912
3913         printf("\n\nStart %s.", __func__);
3914         printf("\nTest to measure max throughput at various pkt sizes.");
3915         printf("\nOn HW devices t'put maximised when high Retries and EmptyPolls"
3916                         " so cycle cost not relevant (n/a displayed).");
3917
3918         for (i = 0; i < RTE_DIM(params_set); i++) {
3919                 printf("\n\n");
3920                 params_set[i].total_operations = total_operations;
3921                 for (k = 0; k < RTE_DIM(burst_sizes); k++) {
3922                         enum rte_crypto_cipher_algorithm cipher_algo =
3923                                 params_set[i].cipher_algo;
3924                         enum rte_crypto_auth_algorithm auth_algo =
3925                                 params_set[i].auth_algo;
3926                         printf("\nOn %s dev%u qp%u, %s, "
3927                                 "cipher algo:%s, auth algo:%s, burst_size: %d ops",
3928                                 pmd_name(gbl_driver_id),
3929                                 testsuite_params.dev_id, 0,
3930                                 chain_mode_name(params_set[i].chain),
3931                                 rte_crypto_cipher_algorithm_strings[cipher_algo],
3932                                 rte_crypto_auth_algorithm_strings[auth_algo],
3933                                 burst_sizes[k]);
3934
3935                         params_set[i].burst_size = burst_sizes[k];
3936                         printf("\nPktSzB\tOp/s(M)\tThruput(Mbps)\tCycles/Burst\t"
3937                                 "Cycles/buf\tCycles/B\tRetries\t\tEmptyPolls\n");
3938                         for (j = 0; j < RTE_DIM(buf_lengths); j++) {
3939
3940                                 params_set[i].buf_size = buf_lengths[j];
3941
3942                                 test_perf_snow3g(testsuite_params.dev_id, 0, &params_set[i]);
3943                         }
3944                 }
3945         }
3946
3947         return 0;
3948 }
3949
3950 static int
3951 test_perf_openssl_vary_pkt_size(void)
3952 {
3953         unsigned int total_operations = 10000;
3954         unsigned int burst_size = { 64 };
3955         unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
3956                         1792, 2048 };
3957         uint8_t i, j;
3958
3959         struct perf_test_params params_set[] = {
3960                 {
3961                         .chain = CIPHER_HASH,
3962
3963                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CBC,
3964                         .key_length = 16,
3965                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3966                 },
3967                 {
3968                         .chain = CIPHER_HASH,
3969
3970                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CBC,
3971                         .key_length = 24,
3972                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3973                 },
3974                 {
3975                         .chain = CIPHER_HASH,
3976
3977                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CTR,
3978                         .key_length = 16,
3979                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3980                 },
3981                 {
3982                         .chain = CIPHER_HASH,
3983
3984                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CTR,
3985                         .key_length = 32,
3986                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3987                 },
3988                 {
3989                         .chain = CIPHER_HASH,
3990
3991                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CTR,
3992                         .key_length = 16,
3993                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
3994                 },
3995                 {
3996                         .chain = CIPHER_HASH,
3997
3998                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CTR,
3999                         .key_length = 24,
4000                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4001                 },
4002                 {
4003                         .chain = AEAD,
4004
4005                         .aead_algo  = RTE_CRYPTO_AEAD_AES_GCM,
4006                         .key_length = 16,
4007                 },
4008         };
4009
4010         for (i = 0; i < RTE_DIM(params_set); i++) {
4011                 params_set[i].total_operations = total_operations;
4012                 params_set[i].burst_size = burst_size;
4013                 if (params_set[i].chain == AEAD) {
4014                         enum rte_crypto_aead_algorithm aead_algo =
4015                                 params_set[i].aead_algo;
4016                         printf("\n%s. aead algo: %s  key size=%u."
4017                                 " burst_size: %d ops\n",
4018                                 chain_mode_name(params_set[i].chain),
4019                                 rte_crypto_aead_algorithm_strings[aead_algo],
4020                                 params_set[i].key_length,
4021                                 burst_size);
4022                 } else {
4023                         enum rte_crypto_cipher_algorithm cipher_algo =
4024                                 params_set[i].cipher_algo;
4025                         enum rte_crypto_auth_algorithm auth_algo =
4026                                 params_set[i].auth_algo;
4027                         printf("\n%s. cipher algo: %s auth algo: %s key size=%u."
4028                                 " burst_size: %d ops\n",
4029                                 chain_mode_name(params_set[i].chain),
4030                                 rte_crypto_cipher_algorithm_strings[cipher_algo],
4031                                 rte_crypto_auth_algorithm_strings[auth_algo],
4032                                 params_set[i].key_length,
4033                                 burst_size);
4034                 }
4035                 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4036                                 "EmptyPolls\n");
4037                 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4038                         params_set[i].buf_size = buf_lengths[j];
4039                         test_perf_openssl(testsuite_params.dev_id, 0,
4040                                         &params_set[i]);
4041                 }
4042         }
4043
4044         return 0;
4045 }
4046
4047 static int
4048 test_perf_openssl_vary_burst_size(void)
4049 {
4050         unsigned int total_operations = 4096;
4051         uint16_t buf_lengths[] = { 40 };
4052         uint8_t i, j;
4053
4054         struct perf_test_params params_set[] = {
4055                 {
4056                         .chain = CIPHER_HASH,
4057
4058                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CBC,
4059                         .key_length = 16,
4060                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4061                 },
4062                 {
4063                         .chain = CIPHER_HASH,
4064
4065                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CBC,
4066                         .key_length = 24,
4067                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4068                 },
4069                 {
4070                         .chain = CIPHER_HASH,
4071
4072                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CTR,
4073                         .key_length = 16,
4074                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4075                 },
4076                 {
4077                         .chain = CIPHER_HASH,
4078
4079                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CTR,
4080                         .key_length = 32,
4081                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4082                 },
4083                 {
4084                         .chain = CIPHER_HASH,
4085
4086                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CTR,
4087                         .key_length = 16,
4088                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4089                 },
4090                 {
4091                         .chain = CIPHER_HASH,
4092
4093                         .cipher_algo  = RTE_CRYPTO_CIPHER_3DES_CTR,
4094                         .key_length = 24,
4095                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4096                 },
4097                 {
4098                         .chain = AEAD,
4099
4100                         .aead_algo  = RTE_CRYPTO_AEAD_AES_GCM,
4101                         .key_length = 16,
4102                 },
4103         };
4104
4105         printf("\n\nStart %s.", __func__);
4106         printf("\nThis Test measures the average IA cycle cost using a "
4107                         "constant request(packet) size. ");
4108         printf("Cycle cost is only valid when indicators show device is not"
4109                         " busy, i.e. Retries and EmptyPolls = 0");
4110
4111         for (i = 0; i < RTE_DIM(params_set); i++) {
4112                 printf("\n");
4113                 params_set[i].total_operations = total_operations;
4114
4115         for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4116                 params_set[i].buf_size = buf_lengths[j];
4117                 test_perf_openssl_optimise_cyclecount(&params_set[i]);
4118                 }
4119         }
4120
4121         return 0;
4122 }
4123
4124 static int
4125 test_perf_armv8_vary_pkt_size(void)
4126 {
4127         unsigned int total_operations = 100000;
4128         unsigned int burst_size = { 64 };
4129         unsigned int buf_lengths[] = { 64, 128, 256, 512, 768, 1024, 1280, 1536,
4130                         1792, 2048 };
4131         uint8_t i, j;
4132
4133         struct perf_test_params params_set[] = {
4134                 {
4135                         .chain = CIPHER_HASH,
4136
4137                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4138                         .key_length = 16,
4139                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4140                 },
4141                 {
4142                         .chain = HASH_CIPHER,
4143
4144                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4145                         .key_length = 16,
4146                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4147                 },
4148                 {
4149                         .chain = CIPHER_HASH,
4150
4151                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4152                         .key_length = 16,
4153                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4154                 },
4155                 {
4156                         .chain = HASH_CIPHER,
4157
4158                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4159                         .key_length = 16,
4160                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4161                 },
4162         };
4163
4164         for (i = 0; i < RTE_DIM(params_set); i++) {
4165                 params_set[i].total_operations = total_operations;
4166                 params_set[i].burst_size = burst_size;
4167                 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4168                         " burst_size: %d ops\n",
4169                         chain_mode_name(params_set[i].chain),
4170                         rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo],
4171                         rte_crypto_auth_algorithm_strings[params_set[i].auth_algo],
4172                         params_set[i].key_length,
4173                         burst_size);
4174                 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t"
4175                                 "EmptyPolls\n");
4176                 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4177                         params_set[i].buf_size = buf_lengths[j];
4178                         test_perf_armv8(testsuite_params.dev_id, 0,
4179                                                         &params_set[i]);
4180                 }
4181         }
4182
4183         return 0;
4184 }
4185
4186 static int
4187 test_perf_armv8_vary_burst_size(void)
4188 {
4189         unsigned int total_operations = 4096;
4190         uint16_t buf_lengths[] = { 64 };
4191         uint8_t i, j;
4192
4193         struct perf_test_params params_set[] = {
4194                 {
4195                         .chain = CIPHER_HASH,
4196
4197                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4198                         .key_length = 16,
4199                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4200                 },
4201                 {
4202                         .chain = HASH_CIPHER,
4203
4204                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4205                         .key_length = 16,
4206                         .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4207                 },
4208                 {
4209                         .chain = CIPHER_HASH,
4210
4211                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4212                         .key_length = 16,
4213                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4214                 },
4215                 {
4216                         .chain = HASH_CIPHER,
4217
4218                         .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4219                         .key_length = 16,
4220                         .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC
4221                 },
4222         };
4223
4224         printf("\n\nStart %s.", __func__);
4225         printf("\nThis Test measures the average IA cycle cost using a "
4226                         "constant request(packet) size. ");
4227         printf("Cycle cost is only valid when indicators show device is "
4228                         "not busy, i.e. Retries and EmptyPolls = 0");
4229
4230         for (i = 0; i < RTE_DIM(params_set); i++) {
4231                 printf("\n");
4232                 params_set[i].total_operations = total_operations;
4233
4234                 for (j = 0; j < RTE_DIM(buf_lengths); j++) {
4235                         params_set[i].buf_size = buf_lengths[j];
4236                         test_perf_armv8_optimise_cyclecount(&params_set[i]);
4237                 }
4238         }
4239
4240         return 0;
4241 }
4242
4243 static int
4244 test_perf_aes_cbc_vary_burst_size(void)
4245 {
4246         return test_perf_crypto_qp_vary_burst_size(testsuite_params.dev_id);
4247 }
4248
4249
4250 static struct rte_cryptodev_sym_session *
4251 test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams)
4252 {
4253         struct crypto_testsuite_params *ts_params = &testsuite_params;
4254         struct rte_crypto_sym_xform aead_xform = { 0 };
4255
4256         uint8_t aead_key[pparams->session_attrs->key_aead_len];
4257
4258         memcpy(aead_key, pparams->session_attrs->key_aead_data,
4259                  pparams->session_attrs->key_aead_len);
4260
4261         aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
4262         aead_xform.next = NULL;
4263
4264         aead_xform.aead.algo = pparams->session_attrs->aead_algorithm;
4265         aead_xform.aead.op = pparams->session_attrs->aead;
4266         aead_xform.aead.key.data = aead_key;
4267         aead_xform.aead.key.length = pparams->session_attrs->key_aead_len;
4268         aead_xform.aead.iv.length = pparams->session_attrs->iv_len;
4269         aead_xform.aead.iv.offset = IV_OFFSET;
4270         aead_xform.aead.aad_length = pparams->session_attrs->aad_len;
4271         aead_xform.aead.digest_length = pparams->session_attrs->digest_len;
4272
4273         test_crypto_session = rte_cryptodev_sym_session_create(ts_params->sess_mp);
4274
4275         rte_cryptodev_sym_session_init(dev_id, test_crypto_session,
4276                                 &aead_xform, ts_params->sess_mp);
4277
4278         return test_crypto_session;
4279 }
4280
4281 static inline struct rte_crypto_op *
4282 perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m,
4283                 struct rte_cryptodev_sym_session *sess,
4284                 struct crypto_params *m_hlp,
4285                 struct perf_test_params *params)
4286 {
4287         uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
4288                         uint8_t *, IV_OFFSET);
4289
4290         if (rte_crypto_op_attach_sym_session(op, sess) != 0) {
4291                 rte_crypto_op_free(op);
4292                 return NULL;
4293         }
4294
4295         op->sym->aead.digest.data = m_hlp->digest;
4296         op->sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(
4297                                           m,
4298                                           params->session_attrs->aad_len +
4299                                           params->symmetric_op->p_len);
4300
4301
4302         op->sym->aead.aad.data = m_hlp->aad;
4303         op->sym->aead.aad.phys_addr = rte_pktmbuf_mtophys(m);
4304
4305         rte_memcpy(op->sym->aead.aad.data, params->symmetric_op->aad_data,
4306                        params->session_attrs->aad_len);
4307
4308         rte_memcpy(iv_ptr, params->session_attrs->iv_data,
4309                        params->session_attrs->iv_len);
4310         if (params->session_attrs->iv_len == 12)
4311                 iv_ptr[15] = 1;
4312
4313         op->sym->aead.data.offset =
4314                         params->session_attrs->aad_len;
4315         op->sym->aead.data.length = params->symmetric_op->p_len;
4316
4317         op->sym->m_src = m;
4318
4319         return op;
4320 }
4321
4322 static struct rte_mbuf *
4323 test_perf_create_pktmbuf_fill(struct rte_mempool *mpool,
4324                 struct perf_test_params *params,
4325                 unsigned buf_sz, struct crypto_params *m_hlp)
4326 {
4327         struct rte_mbuf *m = rte_pktmbuf_alloc(mpool);
4328         uint16_t aad_len = params->session_attrs->aad_len;
4329         uint16_t digest_size = params->symmetric_op->t_len;
4330         char *p;
4331
4332         p = rte_pktmbuf_append(m, aad_len);
4333         if (p == NULL) {
4334                 rte_pktmbuf_free(m);
4335                 return NULL;
4336         }
4337         m_hlp->aad = (uint8_t *)p;
4338
4339         p = rte_pktmbuf_append(m, buf_sz);
4340         if (p == NULL) {
4341                 rte_pktmbuf_free(m);
4342                 return NULL;
4343         }
4344         rte_memcpy(p, params->symmetric_op->p_data, buf_sz);
4345
4346         p = rte_pktmbuf_append(m, digest_size);
4347         if (p == NULL) {
4348                 rte_pktmbuf_free(m);
4349                 return NULL;
4350         }
4351         m_hlp->digest = (uint8_t *)p;
4352
4353         return m;
4354 }
4355
4356 static int
4357 perf_AES_GCM(uint8_t dev_id, uint16_t queue_id,
4358              struct perf_test_params *pparams, uint32_t test_ops)
4359 {
4360         int j = 0;
4361         struct crypto_testsuite_params *ts_params = &testsuite_params;
4362         struct rte_cryptodev_sym_session *sess;
4363         struct rte_crypto_op *ops[pparams->burst_size];
4364         struct rte_crypto_op *proc_ops[pparams->burst_size];
4365         uint32_t total_operations = pparams->total_operations;
4366
4367         uint64_t burst_enqueued = 0, total_enqueued = 0, burst_dequeued = 0;
4368         uint64_t processed = 0, failed_polls = 0, retries = 0;
4369         uint64_t tsc_start = 0, tsc_end = 0;
4370
4371         uint16_t i = 0, l = 0, m = 0;
4372         uint16_t burst = pparams->burst_size * NUM_MBUF_SETS;
4373         uint16_t ops_unused = 0;
4374
4375         struct rte_mbuf *mbufs[burst];
4376         struct crypto_params m_hlp[burst];
4377
4378         if (rte_cryptodev_count() == 0) {
4379                 printf("\nNo crypto devices available. "
4380                                 "Is kernel driver loaded?\n");
4381                 return TEST_FAILED;
4382         }
4383
4384         sess = test_perf_create_session(dev_id, pparams);
4385         TEST_ASSERT_NOT_NULL(sess, "Session creation failed");
4386
4387         for (i = 0; i < burst; i++) {
4388                 mbufs[i] = test_perf_create_pktmbuf_fill(
4389                                 ts_params->mbuf_mp,
4390                                 pparams, pparams->symmetric_op->p_len,
4391                                 &m_hlp[i]);
4392         }
4393
4394         if (test_ops)
4395                 total_operations = test_ops;
4396
4397         tsc_start = rte_rdtsc_precise();
4398         while (total_enqueued < total_operations) {
4399                 uint16_t burst_size =
4400                 total_enqueued+pparams->burst_size <= total_operations ?
4401                 pparams->burst_size : total_operations-total_enqueued;
4402                 uint16_t ops_needed = burst_size-ops_unused;
4403
4404                 if (ops_needed != rte_crypto_op_bulk_alloc(ts_params->op_mpool,
4405                                 RTE_CRYPTO_OP_TYPE_SYMMETRIC, ops, ops_needed)){
4406                         printf("\nFailed to alloc enough ops, "
4407                                         "finish dequeuing");
4408                 } else {
4409                         for (i = 0; i < ops_needed; i++)
4410                                 ops[i] = perf_gcm_set_crypto_op(ops[i],
4411                                         mbufs[i + (pparams->burst_size *
4412                                                 (j % NUM_MBUF_SETS))],
4413                                         sess, &m_hlp[i + (pparams->burst_size *
4414                                                 (j % NUM_MBUF_SETS))], pparams);
4415
4416                         /* enqueue burst */
4417                         burst_enqueued = rte_cryptodev_enqueue_burst(dev_id,
4418                                         queue_id, ops, burst_size);
4419
4420                         if (burst_enqueued < burst_size)
4421                                 retries++;
4422
4423                         ops_unused = burst_size-burst_enqueued;
4424                         total_enqueued += burst_enqueued;
4425                 }
4426
4427                 /* dequeue burst */
4428                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4429                                 proc_ops, pparams->burst_size);
4430                 if (burst_dequeued == 0)
4431                         failed_polls++;
4432                 else {
4433                         processed += burst_dequeued;
4434
4435                         for (l = 0; l < burst_dequeued; l++)
4436                                 rte_crypto_op_free(proc_ops[l]);
4437                 }
4438
4439                 j++;
4440         }
4441
4442         /* Dequeue any operations still in the crypto device */
4443         while (processed < total_operations) {
4444                 /* Sending 0 length burst to flush sw crypto device */
4445                 rte_cryptodev_enqueue_burst(dev_id, queue_id, NULL, 0);
4446
4447                 /* dequeue burst */
4448                 burst_dequeued = rte_cryptodev_dequeue_burst(dev_id, queue_id,
4449                                 proc_ops, pparams->burst_size);
4450                 if (burst_dequeued == 0)
4451                         failed_polls++;
4452                 else {
4453                         processed += burst_dequeued;
4454
4455                 for (m = 0; m < burst_dequeued; m++) {
4456                         if (test_ops) {
4457                                 uint8_t *pkt = rte_pktmbuf_mtod(
4458                                         proc_ops[m]->sym->m_src,
4459                                         uint8_t *);
4460
4461                                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4462                                         pparams->symmetric_op->c_data,
4463                                         pkt +
4464                                         pparams->session_attrs->aad_len,
4465                                         pparams->symmetric_op->c_len,
4466                                         "GCM Ciphertext data not as expected");
4467
4468                                 TEST_ASSERT_BUFFERS_ARE_EQUAL(
4469                                         pparams->symmetric_op->t_data,
4470                                         pkt +
4471                                         pparams->session_attrs->aad_len +
4472                                         pparams->symmetric_op->c_len,
4473                                         pparams->symmetric_op->t_len,
4474                                         "GCM MAC data not as expected");
4475
4476                                 }
4477                                 rte_crypto_op_free(proc_ops[m]);
4478                         }
4479                 }
4480         }
4481
4482         tsc_end = rte_rdtsc_precise();
4483
4484         double ops_s = ((double)processed / (tsc_end - tsc_start))
4485                         * rte_get_tsc_hz();
4486         double throughput = (ops_s * pparams->symmetric_op->p_len * 8)
4487                         / 1000000000;
4488
4489         if (!test_ops) {
4490                 printf("\n%u\t\t%6.2f\t%16.2f\t%8"PRIu64"\t%10"PRIu64,
4491                 pparams->symmetric_op->p_len,
4492                 ops_s/1000000, throughput, retries, failed_polls);
4493         }
4494
4495         for (i = 0; i < burst; i++)
4496                 rte_pktmbuf_free(mbufs[i]);
4497
4498         rte_cryptodev_sym_session_clear(ts_params->dev_id, sess);
4499         rte_cryptodev_sym_session_free(sess);
4500
4501         return 0;
4502 }
4503
4504 static int
4505 test_perf_AES_GCM(int continual_buf_len, int continual_size)
4506 {
4507         uint16_t i, j, k, loops = 1;
4508
4509         uint16_t buf_lengths[] = { 64, 128, 256, 512, 1024, 1536, 2048 };
4510
4511         static const struct cryptodev_perf_test_data *gcm_tests[] = {
4512                         &AES_GCM_128_12IV_0AAD
4513         };
4514
4515         if (continual_buf_len)
4516                 loops = continual_size;
4517
4518         int TEST_CASES_GCM = RTE_DIM(gcm_tests);
4519
4520         const unsigned burst_size = 32;
4521
4522         struct symmetric_op ops_set[TEST_CASES_GCM];
4523         struct perf_test_params params_set[TEST_CASES_GCM];
4524         struct symmetric_session_attrs session_attrs[TEST_CASES_GCM];
4525         static const struct cryptodev_perf_test_data *gcm_test;
4526
4527         for (i = 0; i < TEST_CASES_GCM; ++i) {
4528
4529                 gcm_test = gcm_tests[i];
4530
4531                 session_attrs[i].aead =
4532                                 RTE_CRYPTO_AEAD_OP_ENCRYPT;
4533                 session_attrs[i].aead_algorithm =
4534                                 RTE_CRYPTO_AEAD_AES_GCM;
4535                 session_attrs[i].key_aead_data =
4536                                 gcm_test->key.data;
4537                 session_attrs[i].key_aead_len =
4538                                 gcm_test->key.len;
4539                 session_attrs[i].aad_len = gcm_test->aad.len;
4540                 session_attrs[i].digest_len =
4541                                 gcm_test->auth_tag.len;
4542                 session_attrs[i].iv_len = gcm_test->iv.len;
4543                 session_attrs[i].iv_data = gcm_test->iv.data;
4544
4545                 ops_set[i].aad_data = gcm_test->aad.data;
4546                 ops_set[i].p_data = gcm_test->plaintext.data;
4547                 ops_set[i].p_len = buf_lengths[i];
4548                 ops_set[i].c_data = gcm_test->ciphertext.data;
4549                 ops_set[i].c_len = buf_lengths[i];
4550                 ops_set[i].t_data = gcm_test->auth_tags[i].data;
4551                 ops_set[i].t_len = gcm_test->auth_tags[i].len;
4552
4553                 params_set[i].chain = AEAD;
4554                 params_set[i].session_attrs = &session_attrs[i];
4555                 params_set[i].symmetric_op = &ops_set[i];
4556                 if (continual_buf_len)
4557                         params_set[i].total_operations = 0xFFFFFF;
4558                 else
4559                         params_set[i].total_operations = 1000000;
4560
4561                 params_set[i].burst_size = burst_size;
4562
4563         }
4564
4565         if (continual_buf_len)
4566                 printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4567                         " burst size: %u", "AES_GCM", "AES_GCM",
4568                         gcm_test->key.len << 3, burst_size);
4569
4570         for (i = 0; i < RTE_DIM(gcm_tests); i++) {
4571
4572                 if (!continual_buf_len) {
4573                         printf("\nCipher algo: %s Cipher hash: %s cipher key size: %ub"
4574                                 " burst size: %u", "AES_GCM", "AES_GCM",
4575                                 gcm_test->key.len << 3, burst_size);
4576                         printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4577                                 " Retries\tEmptyPolls");
4578                 }
4579
4580                 uint16_t len = RTE_DIM(buf_lengths);
4581                 uint16_t p = 0;
4582
4583                 if (continual_buf_len) {
4584                         for (k = 0; k < RTE_DIM(buf_lengths); k++)
4585                                 if (buf_lengths[k] == continual_buf_len) {
4586                                         len = k + 1;
4587                                         p = k;
4588                                         break;
4589                                 }
4590                 }
4591                 for (j = p; j < len; ++j) {
4592
4593                         params_set[i].symmetric_op->c_len = buf_lengths[j];
4594                         params_set[i].symmetric_op->p_len = buf_lengths[j];
4595
4596                         ops_set[i].t_data = gcm_tests[i]->auth_tags[j].data;
4597                         ops_set[i].t_len = gcm_tests[i]->auth_tags[j].len;
4598
4599                         /* Run is twice, one for encryption/hash checks,
4600                          * one for perf
4601                          */
4602                         if (perf_AES_GCM(testsuite_params.dev_id, 0,
4603                                         &params_set[i], 1))
4604                                 return TEST_FAILED;
4605
4606                         for (k = 0; k < loops; k++) {
4607                                 if (continual_buf_len)
4608                                         printf("\n\nBuffer Size(B)\tOPS(M)\t"
4609                                                 "Throughput(Gbps)\t"
4610                                                 "Retries\tEmptyPolls");
4611                                 if (perf_AES_GCM(testsuite_params.dev_id, 0,
4612                                                 &params_set[i], 0))
4613                                         return TEST_FAILED;
4614                                 if (continual_buf_len)
4615                                         printf("\n\nCompleted loop %i of %i ...",
4616                                                 k+1, loops);
4617                         }
4618                 }
4619
4620         }
4621         printf("\n");
4622         return 0;
4623 }
4624
4625 static int test_cryptodev_perf_AES_GCM(void)
4626 {
4627         return test_perf_AES_GCM(0, 0);
4628 }
4629 /*
4630  * This function calls AES GCM performance tests providing
4631  * size of packet as an argument. If size of packet is not
4632  * in the buf_lengths array, all sizes will be used
4633  */
4634 static int test_continual_perf_AES_GCM(void)
4635 {
4636         return test_perf_AES_GCM(1024, 10);
4637 }
4638
4639 static int
4640 test_perf_continual_performance_test(void)
4641 {
4642         unsigned int total_operations = 0xFFFFFF;
4643         unsigned int total_loops = 10;
4644         unsigned int burst_size = 32;
4645         uint8_t i;
4646
4647         struct perf_test_params params_set = {
4648                 .total_operations = total_operations,
4649                 .burst_size = burst_size,
4650                 .buf_size = 1024,
4651
4652                 .chain = CIPHER_HASH,
4653
4654                 .cipher_algo  = RTE_CRYPTO_CIPHER_AES_CBC,
4655                 .key_length = 16,
4656                 .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC
4657         };
4658
4659         for (i = 1; i <= total_loops; ++i) {
4660                 printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u."
4661                         " burst_size: %d ops\n",
4662                         chain_mode_name(params_set.chain),
4663                         rte_crypto_cipher_algorithm_strings[params_set.cipher_algo],
4664                         rte_crypto_auth_algorithm_strings[params_set.auth_algo],
4665                         params_set.key_length,
4666                         burst_size);
4667                 printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t"
4668                                 "Retries\tEmptyPolls\n");
4669                                 test_perf_aes_sha(testsuite_params.dev_id, 0,
4670                                         &params_set);
4671                 printf("\nCompleted loop %i of %i ...", i, total_loops);
4672         }
4673         return 0;
4674 }
4675
4676 static struct unit_test_suite cryptodev_qat_continual_testsuite  = {
4677         .suite_name = "Crypto Device Continual Performance Test",
4678         .setup = testsuite_setup,
4679         .teardown = testsuite_teardown,
4680         .unit_test_cases = {
4681                 TEST_CASE_ST(ut_setup, ut_teardown,
4682                                 test_perf_continual_performance_test),
4683                 TEST_CASE_ST(ut_setup, ut_teardown,
4684                                 test_continual_perf_AES_GCM),
4685                 TEST_CASES_END() /**< NULL terminate unit test array */
4686         }
4687 };
4688
4689 static struct unit_test_suite cryptodev_testsuite  = {
4690         .suite_name = "Crypto Device Unit Test Suite",
4691         .setup = testsuite_setup,
4692         .teardown = testsuite_teardown,
4693         .unit_test_cases = {
4694                 TEST_CASE_ST(ut_setup, ut_teardown,
4695                                 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4696                 TEST_CASE_ST(ut_setup, ut_teardown,
4697                                 test_cryptodev_perf_AES_GCM),
4698                 TEST_CASE_ST(ut_setup, ut_teardown,
4699                                 test_perf_aes_cbc_vary_burst_size),
4700                 TEST_CASES_END() /**< NULL terminate unit test array */
4701         }
4702 };
4703
4704 static struct unit_test_suite cryptodev_dpaa2_sec_testsuite  = {
4705         .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite",
4706         .setup = testsuite_setup,
4707         .teardown = testsuite_teardown,
4708         .unit_test_cases = {
4709                 TEST_CASE_ST(ut_setup, ut_teardown,
4710                              test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4711                 TEST_CASES_END() /**< NULL terminate unit test array */
4712         }
4713 };
4714
4715 static struct unit_test_suite cryptodev_gcm_testsuite  = {
4716         .suite_name = "Crypto Device AESNI GCM Unit Test Suite",
4717         .setup = testsuite_setup,
4718         .teardown = testsuite_teardown,
4719         .unit_test_cases = {
4720                 TEST_CASE_ST(ut_setup, ut_teardown,
4721                                 test_cryptodev_perf_AES_GCM),
4722                 TEST_CASES_END() /**< NULL terminate unit test array */
4723         }
4724 };
4725
4726 static struct unit_test_suite cryptodev_aes_testsuite  = {
4727         .suite_name = "Crypto Device AESNI MB Unit Test Suite",
4728         .setup = testsuite_setup,
4729         .teardown = testsuite_teardown,
4730         .unit_test_cases = {
4731                 TEST_CASE_ST(ut_setup, ut_teardown,
4732                                 test_perf_aes_cbc_encrypt_digest_vary_pkt_size),
4733                 TEST_CASES_END() /**< NULL terminate unit test array */
4734         }
4735 };
4736
4737 static struct unit_test_suite cryptodev_snow3g_testsuite  = {
4738         .suite_name = "Crypto Device SNOW3G Unit Test Suite",
4739         .setup = testsuite_setup,
4740         .teardown = testsuite_teardown,
4741         .unit_test_cases = {
4742                 TEST_CASE_ST(ut_setup, ut_teardown,
4743                                 test_perf_snow3G_vary_pkt_size),
4744                 TEST_CASE_ST(ut_setup, ut_teardown,
4745                                 test_perf_snow3G_vary_burst_size),
4746                 TEST_CASES_END() /**< NULL terminate unit test array */
4747         }
4748 };
4749
4750 static struct unit_test_suite cryptodev_openssl_testsuite  = {
4751         .suite_name = "Crypto Device OPENSSL Unit Test Suite",
4752         .setup = testsuite_setup,
4753         .teardown = testsuite_teardown,
4754         .unit_test_cases = {
4755                 TEST_CASE_ST(ut_setup, ut_teardown,
4756                                 test_perf_openssl_vary_pkt_size),
4757                 TEST_CASE_ST(ut_setup, ut_teardown,
4758                                 test_perf_openssl_vary_burst_size),
4759                 TEST_CASES_END() /**< NULL terminate unit test array */
4760         }
4761 };
4762
4763 static struct unit_test_suite cryptodev_armv8_testsuite  = {
4764         .suite_name = "Crypto Device ARMv8 Unit Test Suite",
4765         .setup = testsuite_setup,
4766         .teardown = testsuite_teardown,
4767         .unit_test_cases = {
4768                 TEST_CASE_ST(ut_setup, ut_teardown,
4769                                 test_perf_armv8_vary_pkt_size),
4770                 TEST_CASE_ST(ut_setup, ut_teardown,
4771                                 test_perf_armv8_vary_burst_size),
4772                 TEST_CASES_END() /**< NULL terminate unit test array */
4773         }
4774 };
4775
4776 static int
4777 perftest_aesni_gcm_cryptodev(void)
4778 {
4779         gbl_driver_id = rte_cryptodev_driver_id_get(
4780                         RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
4781
4782         if (gbl_driver_id == -1) {
4783                 RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded. Check if "
4784                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled "
4785                                 "in config file to run this testsuite.\n");
4786                 return TEST_FAILED;
4787         }
4788
4789         return unit_test_suite_runner(&cryptodev_gcm_testsuite);
4790 }
4791
4792 static int
4793 perftest_aesni_mb_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4794 {
4795         gbl_driver_id = rte_cryptodev_driver_id_get(
4796                         RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
4797
4798         if (gbl_driver_id == -1) {
4799                 RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded. Check if "
4800                                 "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled "
4801                                 "in config file to run this testsuite.\n");
4802                 return TEST_FAILED;
4803         }
4804
4805         return unit_test_suite_runner(&cryptodev_aes_testsuite);
4806 }
4807
4808 static int
4809 perftest_qat_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4810 {
4811         gbl_driver_id = rte_cryptodev_driver_id_get(
4812                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4813
4814         if (gbl_driver_id == -1) {
4815                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4816                                 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4817                                 "in config file to run this testsuite.\n");
4818                 return TEST_FAILED;
4819         }
4820
4821         return unit_test_suite_runner(&cryptodev_testsuite);
4822 }
4823
4824 static int
4825 perftest_sw_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4826 {
4827         gbl_driver_id = rte_cryptodev_driver_id_get(
4828                         RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
4829
4830         if (gbl_driver_id == -1) {
4831                 RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded. Check if "
4832                                 "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled "
4833                                 "in config file to run this testsuite.\n");
4834                 return TEST_FAILED;
4835         }
4836
4837         return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4838 }
4839
4840 static int
4841 perftest_qat_snow3g_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4842 {
4843         gbl_driver_id = rte_cryptodev_driver_id_get(
4844                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4845
4846         if (gbl_driver_id == -1) {
4847                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4848                                 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4849                                 "in config file to run this testsuite.\n");
4850                 return TEST_FAILED;
4851         }
4852
4853         return unit_test_suite_runner(&cryptodev_snow3g_testsuite);
4854 }
4855
4856 static int
4857 perftest_openssl_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4858 {
4859         gbl_driver_id = rte_cryptodev_driver_id_get(
4860                         RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
4861
4862         if (gbl_driver_id == -1) {
4863                 RTE_LOG(ERR, USER1, "OpenSSL PMD must be loaded. Check if "
4864                                 "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled "
4865                                 "in config file to run this testsuite.\n");
4866                 return TEST_FAILED;
4867         }
4868
4869         return unit_test_suite_runner(&cryptodev_openssl_testsuite);
4870 }
4871
4872 static int
4873 perftest_qat_continual_cryptodev(void)
4874 {
4875         gbl_driver_id = rte_cryptodev_driver_id_get(
4876                         RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
4877
4878         if (gbl_driver_id == -1) {
4879                 RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check if "
4880                                 "CONFIG_RTE_LIBRTE_PMD_QAT is enabled "
4881                                 "in config file to run this testsuite.\n");
4882                 return TEST_FAILED;
4883         }
4884
4885         return unit_test_suite_runner(&cryptodev_qat_continual_testsuite);
4886 }
4887
4888 static int
4889 perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/)
4890 {
4891         gbl_driver_id = rte_cryptodev_driver_id_get(
4892                         RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
4893
4894         if (gbl_driver_id == -1) {
4895                 RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded. Check if "
4896                                 "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled "
4897                                 "in config file to run this testsuite.\n");
4898                 return TEST_FAILED;
4899         }
4900
4901         return unit_test_suite_runner(&cryptodev_armv8_testsuite);
4902 }
4903
4904 static int
4905 perftest_dpaa2_sec_cryptodev(void)
4906 {
4907         gbl_driver_id = rte_cryptodev_driver_id_get(
4908                         RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
4909
4910         if (gbl_driver_id == -1) {
4911                 RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if "
4912                                 "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled "
4913                                 "in config file to run this testsuite.\n");
4914                 return TEST_FAILED;
4915         }
4916
4917         return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite);
4918 }
4919
4920 REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev);
4921 REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev);
4922 REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev);
4923 REGISTER_TEST_COMMAND(cryptodev_qat_snow3g_perftest, perftest_qat_snow3g_cryptodev);
4924 REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_perftest, perftest_aesni_gcm_cryptodev);
4925 REGISTER_TEST_COMMAND(cryptodev_openssl_perftest,
4926                 perftest_openssl_cryptodev);
4927 REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest,
4928                 perftest_qat_continual_cryptodev);
4929 REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest,
4930                 perftest_sw_armv8_cryptodev);
4931 REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest,
4932                       perftest_dpaa2_sec_cryptodev);