1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019 Intel Corporation
5 #include <rte_cryptodev.h>
6 #include <rte_cryptodev_pmd.h>
8 #include "fips_dev_self_test.h"
10 #define IV_OFF (sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op))
12 #define FIPS_DEV_TEST_DATA_MAX_SIZE 8096
14 struct fips_dev_self_test_vector {
16 enum rte_crypto_sym_xform_type operation_type;
35 enum rte_crypto_cipher_algorithm algo;
39 enum rte_crypto_aead_algorithm algo;
41 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
47 enum rte_crypto_auth_algorithm algo;
52 const uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
57 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
62 #define GET_MBUF_DATA(data, len, m) \
64 len = rte_pktmbuf_pkt_len(m); \
65 data = rte_pktmbuf_mtod(m, uint8_t *); \
69 /* <-- SHA-x HMAC --> */
70 static struct fips_dev_self_test_vector
71 SELF_TEST_SHA1_HMAC_test_vector = {
72 .name = "SELF_TEST_SHA1_HMAC_test_vector",
73 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
76 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
80 0xed, 0xb2, 0xba, 0x09, 0x99, 0x61, 0xd3, 0x8f,
81 0xd0, 0xa0, 0xa6, 0xa2, 0x35, 0xd6, 0x12, 0x71,
82 0xcb, 0x4d, 0x49, 0x3b, 0x64, 0xd9, 0xde, 0x13,
83 0x5c, 0xbb, 0x1f, 0xe0, 0x86, 0xc4, 0xa4, 0xa7,
84 0x67, 0xbe, 0x28, 0x0d, 0xa2, 0x07, 0x98, 0x17,
85 0xb4, 0x7f, 0x6a, 0x35, 0xe1, 0xa4, 0x30, 0x7f,
86 0x6e, 0xfc, 0x6d, 0x3e, 0x11, 0xb4, 0xa7, 0xae,
87 0xa6, 0x86, 0xbd, 0x02, 0x23, 0xe0, 0x7b, 0xa9,
88 0xce, 0x42, 0x6c, 0xd0, 0xae, 0xe7, 0xef, 0x28,
89 0x3f, 0xa9, 0x8d, 0xe9, 0x6a, 0x1f, 0x8a, 0x17,
90 0xb3, 0x08, 0xba, 0x04, 0xb5, 0xec, 0x96, 0x16,
91 0xcb, 0x00, 0x8f, 0xca, 0x11, 0x4b, 0xa3, 0xf9,
92 0x8b, 0x07, 0x2d, 0x5a, 0xa3, 0x4a, 0x01, 0x49,
93 0xd9, 0xe5, 0xb8, 0xc6, 0xb6, 0x8c, 0x49, 0xc1,
94 0x01, 0x38, 0xda, 0x95, 0x36, 0xca, 0xd5, 0xd2,
95 0x34, 0xf1, 0x3d, 0x3f, 0x36, 0x4d, 0x43, 0x1f
101 0x8d, 0x8d, 0x15, 0xd8, 0xa9, 0x57, 0x9a, 0xdb,
108 0x0c, 0x66, 0x2e, 0x47, 0x93, 0x93, 0x8c, 0xc3,
109 0x7f, 0x3d, 0x51, 0xd2, 0xb4, 0x05, 0x48, 0xec,
110 0x55, 0x91, 0x4f, 0x0d
116 static struct fips_dev_self_test_vector
117 SELF_TEST_SHA224_HMAC_test_vector = {
118 .name = "SELF_TEST_SHA224_HMAC_test_vector",
119 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
121 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
125 0x41, 0x18, 0x43, 0xa2, 0x13, 0x87, 0x84, 0x6f,
126 0x3b, 0x9e, 0xd5, 0xfc, 0x54, 0x5a, 0xca, 0xdf,
127 0xa5, 0xb7, 0x03, 0x86, 0xf6, 0x2d, 0xa4, 0xd9,
128 0xa2, 0x7b, 0x04, 0x1b, 0xee, 0xa3, 0xaa, 0x11,
129 0x99, 0x36, 0x75, 0x67, 0xb4, 0xd1, 0x1a, 0x4f,
130 0xb4, 0xe8, 0xd4, 0x6b, 0xc6, 0xc2, 0x56, 0xed,
131 0x62, 0xc5, 0x05, 0xfd, 0x23, 0xf4, 0x64, 0x5b,
132 0xd6, 0xb6, 0xcf, 0x45, 0xd1, 0xd9, 0x6d, 0x9b,
133 0x86, 0xd6, 0x60, 0x41, 0x57, 0x57, 0x3e, 0xc5,
134 0xac, 0xf6, 0xc5, 0x41, 0x43, 0x48, 0xca, 0x83,
135 0xc8, 0x1a, 0x73, 0x6c, 0xa6, 0xfa, 0xa6, 0x96,
136 0x1c, 0xfa, 0xc1, 0x39, 0x93, 0xb0, 0x8c, 0x50,
137 0x2f, 0x81, 0x6c, 0xf7, 0xa4, 0x20, 0xd9, 0x18,
138 0x4b, 0x51, 0x11, 0x46, 0x75, 0xf3, 0x0e, 0xe9,
139 0xff, 0x3d, 0xb6, 0x9c, 0x26, 0x48, 0x53, 0xd3,
140 0x9d, 0xcd, 0x42, 0xc1, 0xdd, 0x31, 0xef, 0x79
147 0x37, 0x14, 0x70, 0x78, 0x39, 0xda, 0xf7, 0x91,
148 0x22, 0xc7, 0x82, 0x41, 0x63, 0x51, 0x38, 0x5e,
149 0x88, 0xa8, 0x1d, 0x31, 0xc9, 0xf6, 0x41, 0xd8,
150 0xdc, 0xe5, 0x38, 0xe9, 0x0e, 0x63, 0xc9, 0x58,
151 0x92, 0xa2, 0xea, 0x9b, 0x19, 0x62, 0xed, 0x0b,
152 0xa3, 0x72, 0xf4, 0x8e, 0x94, 0x74, 0xaa, 0x73,
159 0x33, 0xf1, 0x7a, 0xc8, 0xa5, 0xc6, 0xb5, 0x25,
160 0xdb, 0x8b, 0x86, 0x44, 0xb6, 0xab
168 static struct fips_dev_self_test_vector
169 SELF_TEST_SHA256_HMAC_test_vector = {
170 .name = "SELF_TEST_SHA256_HMAC_test_vector",
171 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
173 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
177 0x1c, 0x43, 0x96, 0xf7, 0xb7, 0xf9, 0x22, 0x8e,
178 0x83, 0x2a, 0x13, 0x69, 0x20, 0x02, 0xba, 0x2a,
179 0xff, 0x43, 0x9d, 0xcb, 0x7f, 0xdd, 0xbf, 0xd4,
180 0x56, 0xc0, 0x22, 0xd1, 0x33, 0xee, 0x89, 0x03,
181 0xa2, 0xd4, 0x82, 0x56, 0x2f, 0xda, 0xa4, 0x93,
182 0xce, 0x39, 0x16, 0xd7, 0x7a, 0x0c, 0x51, 0x44,
183 0x1d, 0xab, 0x26, 0xf6, 0xb0, 0x34, 0x02, 0x38,
184 0xa3, 0x6a, 0x71, 0xf8, 0x7f, 0xc3, 0xe1, 0x79,
185 0xca, 0xbc, 0xa9, 0x48, 0x2b, 0x70, 0x49, 0x71,
186 0xce, 0x69, 0xf3, 0xf2, 0x0a, 0xb6, 0x4b, 0x70,
187 0x41, 0x3d, 0x6c, 0x29, 0x08, 0x53, 0x2b, 0x2a,
188 0x88, 0x8a, 0x9f, 0xc2, 0x24, 0xca, 0xe1, 0x36,
189 0x5d, 0xa4, 0x10, 0xb6, 0xf2, 0xe2, 0x98, 0x90,
190 0x4b, 0x63, 0xb4, 0xa4, 0x17, 0x26, 0x32, 0x18,
191 0x35, 0xa4, 0x77, 0x4d, 0xd0, 0x63, 0xc2, 0x11,
192 0xcf, 0xc8, 0xb5, 0x16, 0x6c, 0x2d, 0x11, 0xa2
198 0x54, 0x48, 0x99, 0x8f, 0x9d, 0x8f, 0x98, 0x53,
199 0x4a, 0xdd, 0xf0, 0xc8, 0xba, 0x63, 0x1c, 0x49,
200 0x6b, 0xf8, 0xa8, 0x00, 0x6c, 0xbb, 0x46, 0xad,
201 0x15, 0xfa, 0x1f, 0xa2, 0xf5, 0x53, 0x67, 0x12,
202 0x0c, 0x19, 0x34, 0x8c, 0x3a, 0xfa, 0x90, 0xc3
208 0x7e, 0x8c, 0xba, 0x9d, 0xd9, 0xf0, 0x6e, 0xbd,
209 0xd7, 0xf9, 0x2e, 0x0f, 0x1a, 0x67, 0xc7, 0xf4,
210 0xdf, 0x52, 0x69, 0x3c, 0x21, 0x2b, 0xdd, 0x84,
211 0xf6, 0x73, 0x70, 0xb3, 0x51, 0x53, 0x3c, 0x6c
217 /* HMAC count=34 L=48 SHA384 GENERATE*/
218 static struct fips_dev_self_test_vector
219 SELF_TEST_SHA384_HMAC_test_vector = {
220 .name = "SELF_TEST_SHA384_HMAC_test_vector",
221 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
223 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
227 0xf5, 0x10, 0x86, 0xfe, 0x78, 0x15, 0x0f, 0xe4,
228 0x8b, 0xd1, 0x41, 0x5a, 0x47, 0x85, 0xac, 0xc0,
229 0x5a, 0xb8, 0x0e, 0xf0, 0x0b, 0x29, 0x75, 0xce,
230 0x78, 0x07, 0xa4, 0x21, 0x22, 0x64, 0xb8, 0xa1,
231 0xac, 0xe8, 0x0b, 0x50, 0xe0, 0xc2, 0x59, 0x0e,
232 0xf3, 0xe4, 0x21, 0x68, 0x0a, 0x70, 0x4e, 0xb2,
233 0xfc, 0x6d, 0x17, 0x55, 0x5a, 0xbf, 0x24, 0x69,
234 0xad, 0x56, 0xf2, 0x87, 0xfe, 0xa5, 0x78, 0xd8,
235 0x9c, 0x56, 0x0b, 0x72, 0x19, 0x3c, 0x7f, 0xe5,
236 0x96, 0x89, 0x8f, 0x10, 0x40, 0x41, 0x7e, 0x3a,
237 0x1b, 0xee, 0xff, 0x5e, 0xff, 0x96, 0x53, 0xc5,
238 0xe0, 0xea, 0xb1, 0xda, 0x52, 0xc0, 0xea, 0x3b,
239 0x4b, 0xc3, 0x4d, 0x0c, 0x2b, 0x69, 0xc8, 0x90,
240 0xfb, 0x26, 0x51, 0xfa, 0xf2, 0xe0, 0x84, 0x80,
241 0x3e, 0xa2, 0x8e, 0xb2, 0x01, 0x94, 0x49, 0x0a,
242 0x99, 0x2b, 0xa8, 0xc4, 0x24, 0x9d, 0x56, 0xef
248 0x91, 0x7a, 0x69, 0x8c, 0x82, 0xf4, 0x4f, 0x19,
249 0x57, 0x3b, 0x64, 0x5c, 0x48, 0x79, 0xb8, 0x73,
250 0x0b, 0x58, 0xdf, 0xf4, 0xed, 0xc6, 0xa0, 0xd3,
251 0x21, 0xf5, 0xf1, 0x86, 0x58, 0xa5, 0x24, 0x66,
252 0x92, 0xa5, 0x5b, 0x59, 0x33, 0x97, 0x41, 0xae,
253 0x59, 0xf5, 0xfc, 0x48, 0x6d, 0x51, 0x5d, 0xff,
260 0x77, 0xbf, 0x56, 0x15, 0xec, 0x52, 0xf7, 0x06,
261 0xca, 0x74, 0x64, 0x01, 0xe9, 0xfd, 0xe4, 0x3f,
262 0x15, 0x60, 0x52, 0x37, 0xe5, 0x50, 0xb9, 0x3a,
263 0x84, 0x72, 0xfd, 0x14, 0x4f, 0xc3, 0x9e, 0x5e,
264 0xca, 0x0f, 0xe8, 0x90, 0x83, 0x88, 0x28, 0xa0
270 /* HMAC count=28 L=64 SHA512 GENERATE*/
271 static struct fips_dev_self_test_vector
272 SELF_TEST_SHA512_HMAC_test_vector = {
273 .name = "SELF_TEST_SHA512_HMAC_test_vector",
274 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
276 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
280 0x0a, 0x33, 0x1c, 0xe2, 0x00, 0x89, 0xb2, 0x9e,
281 0x94, 0xb2, 0xc5, 0xf5, 0x18, 0xc8, 0xdb, 0xea,
282 0xd4, 0x04, 0x17, 0xa2, 0xa8, 0xd5, 0x00, 0x18,
283 0xf3, 0x2f, 0x85, 0x12, 0xb3, 0x26, 0x3d, 0x54,
284 0xed, 0xbb, 0xf3, 0x13, 0x4f, 0xf6, 0x61, 0xac,
285 0x14, 0x35, 0x3c, 0x96, 0x28, 0xc3, 0x71, 0x95,
286 0x8c, 0xac, 0xaf, 0x31, 0xfd, 0xd0, 0x25, 0x67,
287 0xd0, 0x37, 0x8d, 0x9e, 0x21, 0xa4, 0x69, 0xdd,
288 0x2c, 0x6d, 0x8c, 0x3a, 0xfb, 0x89, 0xdd, 0x96,
289 0x42, 0xeb, 0x58, 0x87, 0x87, 0x0e, 0x55, 0x96,
290 0x85, 0xd2, 0x0d, 0xab, 0xd3, 0x86, 0x5a, 0xc5,
291 0xc1, 0x46, 0xbe, 0xee, 0x83, 0x87, 0xa7, 0x6f,
292 0x91, 0xf0, 0xf1, 0x40, 0x4d, 0x6c, 0xad, 0xc2,
293 0xe6, 0x7d, 0x21, 0xb0, 0x7d, 0xd3, 0x0f, 0x53,
294 0x87, 0x1d, 0x3b, 0xf6, 0x73, 0x1f, 0x27, 0x9a,
295 0x8c, 0x04, 0x21, 0xeb, 0x20, 0xf6, 0x7f, 0x72
301 0x39, 0xb8, 0x77, 0xb8, 0xe8, 0x2e, 0xcb, 0xd9,
302 0x74, 0x03, 0x25, 0x82, 0x8f, 0xaf, 0x67, 0x21,
303 0xc1, 0x29, 0x04, 0x6e, 0xb0, 0x13, 0x61, 0x44,
304 0xa0, 0x31, 0x82, 0xb1, 0x36, 0x20, 0xe2, 0x49,
305 0x81, 0x45, 0xa2, 0xbf, 0x3b, 0x03, 0xe6, 0xb6,
306 0x4b, 0x31, 0x7d, 0xd4, 0x8f, 0xcb, 0xc0, 0x18,
307 0xd9, 0xe7, 0xbc, 0x6e, 0x37, 0xeb, 0x93, 0x81,
308 0x78, 0xfe, 0x1f, 0xd1, 0xeb, 0xbc, 0xd9, 0x05,
309 0x6a, 0x2e, 0xf9, 0x82, 0x97, 0xf9, 0xdf, 0x3c,
310 0x66, 0xd5, 0xb2, 0xcc, 0xdc, 0x41, 0x47, 0xc4,
311 0x16, 0x76, 0x44, 0x3f, 0x8c, 0x99, 0x85, 0xbc,
312 0x97, 0x34, 0xbe, 0x2c, 0x31, 0xe7, 0x62, 0x49,
313 0xfc, 0x5b, 0xc4, 0x2a
319 0x97, 0x16, 0x8f, 0x55, 0x13, 0xc2, 0xe9, 0xbc,
320 0x4b, 0xc5, 0x25, 0xce, 0x27, 0x03, 0x74, 0x0b,
321 0xce, 0x1a, 0x06, 0xec, 0xfe, 0x99, 0xa5, 0x70,
322 0xac, 0x66, 0xc8, 0x3e, 0xde, 0x96, 0x67, 0xcc,
323 0x07, 0xed, 0xf6, 0x64, 0x61, 0x7c, 0xe5, 0x3c
329 /* <-- AES CMAC --> */
330 static struct fips_dev_self_test_vector
331 SELF_TEST_AES_CMAC_test_vector = {
332 .name = "SELF_TEST_AES_CMAC_test_vector",
333 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
335 .algo = RTE_CRYPTO_AUTH_AES_CMAC,
339 0x57, 0x88, 0xf6, 0x1e, 0x02, 0x30, 0x47, 0x91,
340 0xb5, 0x2f, 0x40, 0x05, 0x7a, 0xbb, 0x4e, 0x04,
341 0x46, 0x40, 0x3e, 0xf3, 0x74, 0x02, 0x53, 0xdf,
342 0x72, 0x05, 0x96, 0x79, 0xbb, 0x2a, 0x6e, 0x5e,
343 0x05, 0x9a, 0x70, 0x9c, 0xbb
349 0x18, 0x42, 0x15, 0x14, 0x5d, 0xa4, 0x9d, 0xb4,
350 0x17, 0xe8, 0xbd, 0xd5, 0x73, 0xd6, 0x28, 0x2d
356 0x8d, 0xa8, 0xcc, 0xa9, 0xb3, 0x6f, 0x68, 0x57,
357 0x1c, 0x6c, 0x0e, 0x40, 0xa3, 0xf4, 0x10
363 /* <-- AES CCM --> */
364 static struct fips_dev_self_test_vector
365 SELF_TEST_AES128_CCM_test_vector = {
366 .name = "SELF_TEST_AES128_CCM_test_vector",
367 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
370 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
371 0x03, 0x97, 0x76, 0xE7, 0x0C
376 .algo = RTE_CRYPTO_AEAD_AES_CCM,
379 /* 18 bytes padding for AAD */
380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
383 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
384 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
385 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00
392 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
393 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
394 0x7E, 0x78, 0xA0, 0x50
400 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
401 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
407 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
408 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
409 0x3C, 0x04, 0xD0, 0x19
415 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23
421 /* <-- AES CBC --> */
422 static struct fips_dev_self_test_vector
423 SELF_TEST_AES128_CBC_test_vector = {
424 .name = "SELF_TEST_AES128_CBC_test_vector",
425 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
429 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
430 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
435 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
439 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
440 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
441 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
442 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
448 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
449 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
455 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
456 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
457 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
458 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
464 static struct fips_dev_self_test_vector
465 SELF_TEST_AES192_CBC_test_vector = {
466 .name = "SELF_TEST_AES192_CBC_test_vector",
467 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
471 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
472 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
477 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
481 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
482 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
483 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
484 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
490 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
491 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
492 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
498 0x45, 0xEE, 0x9A, 0xEA, 0x3C, 0x03, 0xFC, 0x4C,
499 0x84, 0x36, 0xB0, 0xDA, 0xB0, 0xDC, 0xF3, 0x5B,
500 0x75, 0xA7, 0xBE, 0x0E, 0xC0, 0x8D, 0x6C, 0xF8,
501 0xC1, 0x0F, 0xD0, 0x35, 0x1D, 0x82, 0xAE, 0x7C,
507 /* AES-256 CBC ENCRYPT*/
508 static struct fips_dev_self_test_vector
509 SELF_TEST_AES256_CBC_test_vector = {
510 .name = "SELF_TEST_AES256_CBC_test_vector",
511 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
515 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
516 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
521 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
525 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
526 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
527 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
528 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
534 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
535 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
536 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
537 0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
543 0xF3, 0xDD, 0xF0, 0x0B, 0xFF, 0xA2, 0x6A, 0x04,
544 0xBE, 0xDA, 0x52, 0xA6, 0xFE, 0x6B, 0xA6, 0xA7,
545 0x48, 0x1D, 0x7D, 0x98, 0x65, 0xDB, 0xEF, 0x06,
546 0x26, 0xB5, 0x8E, 0xEB, 0x05, 0x0E, 0x77, 0x98,
552 /* DES-128 CBC ENCRYPT*/
553 static struct fips_dev_self_test_vector
554 SELF_TEST_3DES_2KEY_CBC_test_vector = {
555 .name = "SELF_TEST_3DES_2KEY_CBC_test_vector",
556 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
559 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
564 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
568 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
569 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
570 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
571 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
577 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
578 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
579 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2
585 0x28, 0x2a, 0xff, 0x15, 0x5c, 0xdf, 0xd9, 0x6b,
586 0x54, 0xbc, 0x7b, 0xfb, 0xc5, 0x64, 0x4d, 0xdd,
587 0x3e, 0xf2, 0x9e, 0xb7, 0x53, 0x65, 0x37, 0x05,
588 0xe0, 0xdf, 0xae, 0xf7, 0xc9, 0x27, 0xe4, 0xec,
594 static struct fips_dev_self_test_vector
595 SELF_TEST_3DES_3KEY_CBC_test_vector = {
596 .name = "SELF_TEST_3DES_3KEY_CBC_test_vector",
597 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
601 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
606 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
610 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
611 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
612 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
613 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
619 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
620 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
621 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
627 0xd0, 0xc9, 0xdc, 0x51, 0x29, 0x97, 0x03, 0x64,
628 0xcd, 0x22, 0xba, 0x3d, 0x2b, 0xbc, 0x21, 0x37,
629 0x7b, 0x1e, 0x29, 0x23, 0xeb, 0x51, 0x6e, 0xac,
630 0xbe, 0x5b, 0xd3, 0x67, 0xe0, 0x3f, 0xc3, 0xb5,
636 /* <-- AES GCM --> */
637 static struct fips_dev_self_test_vector
638 SELF_TEST_AES128_GCM_encrypt_test_vector = {
639 .name = "SELF_TEST_AES128_GCM_encrypt_test_vector",
640 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
644 0x5a, 0xdb, 0x96, 0x09, 0xdb, 0xae, 0xb5, 0x8c,
645 0xbd, 0x6e, 0x72, 0x75
650 .algo = RTE_CRYPTO_AEAD_AES_GCM,
653 0x88, 0x31, 0x9d, 0x6e, 0x1d, 0x3f, 0xfa, 0x5f,
654 0x98, 0x71, 0x99, 0x16, 0x6c, 0x8a, 0x9b, 0x56,
655 0xc2, 0xae, 0xba, 0x5a
662 0x7c, 0x0e, 0x88, 0xc8, 0x88, 0x99, 0xa7, 0x79,
663 0x22, 0x84, 0x65, 0x07, 0x47, 0x97, 0xcd, 0x4c,
664 0x2e, 0x14, 0x98, 0xd2, 0x59, 0xb5, 0x43, 0x90,
665 0xb8, 0x5e, 0x3e, 0xef, 0x1c, 0x02, 0xdf, 0x60,
666 0xe7, 0x43, 0xf1, 0xb8, 0x40, 0x38, 0x2c, 0x4b,
667 0xcc, 0xaf, 0x3b, 0xaf, 0xb4, 0xca, 0x84, 0x29,
674 0xfe, 0x47, 0xfc, 0xce, 0x5f, 0xc3, 0x26, 0x65,
675 0xd2, 0xae, 0x39, 0x9e, 0x4e, 0xec, 0x72, 0xba
681 0x98, 0xf4, 0x82, 0x6f, 0x05, 0xa2, 0x65, 0xe6,
682 0xdd, 0x2b, 0xe8, 0x2d, 0xb2, 0x41, 0xc0, 0xfb,
683 0xbb, 0xf9, 0xff, 0xb1, 0xc1, 0x73, 0xaa, 0x83,
684 0x96, 0x4b, 0x7c, 0xf5, 0x39, 0x30, 0x43, 0x73,
685 0x63, 0x65, 0x25, 0x3d, 0xdb, 0xc5, 0xdb, 0x87,
686 0x78, 0x37, 0x14, 0x95, 0xda, 0x76, 0xd2, 0x69,
693 0x29, 0x1e, 0xf1, 0x98, 0x2e, 0x4d, 0xef, 0xed,
694 0xaa, 0x22, 0x49, 0xf8, 0x98, 0x55, 0x6b, 0x47
700 static struct fips_dev_self_test_vector
701 SELF_TEST_AES192_GCM_encrypt_test_vector = {
702 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
703 .name = "SELF_TEST_AES192_GCM_encrypt_test_vector",
706 0x0b, 0xd4, 0x4f, 0xf4, 0xd2, 0x0c, 0x15, 0xd0,
707 0x4f, 0xc6, 0x1e, 0xe7
712 .algo = RTE_CRYPTO_AEAD_AES_GCM,
715 0x9e, 0xa4, 0x2c, 0x50, 0xa7, 0xfd, 0xb8, 0x5e,
716 0x14, 0x1a, 0xa0, 0x84, 0xb4, 0x6b, 0xde, 0x12
723 0x56, 0x7c, 0xcb, 0x3f, 0xa0, 0xdb, 0x89, 0x70,
724 0x8a, 0xf3, 0xff, 0x2b, 0xb0, 0x29, 0xdd, 0xec,
725 0x52, 0xc6, 0x69, 0x47, 0x58, 0x5d, 0x29, 0x1a,
726 0x28, 0x56, 0x4b, 0xf5, 0x6d, 0xb7, 0x06, 0xf7
732 0x0d, 0x4a, 0x90, 0x0d, 0x1b, 0x0b, 0xb5, 0xb7,
733 0xbe, 0x24, 0x38, 0xc2, 0xba, 0x48, 0xfc, 0x45,
734 0x13, 0x4c, 0xc1, 0x98, 0x10, 0x8c, 0xf8, 0x85
740 0x2f, 0x8a, 0x42, 0xcd, 0x18, 0x3b, 0x03, 0x14,
741 0xfd, 0x20, 0xa3, 0xd9, 0x7d, 0x9e, 0x0c, 0x52,
742 0x17, 0xb0, 0xf0, 0x88, 0xd2, 0xca, 0x87, 0xa8,
743 0x29, 0x0d, 0x4b, 0xae, 0x69, 0xad, 0x83, 0xf5
749 0xde, 0x41, 0x45, 0x92, 0xd7, 0x7f, 0x2f, 0x0b,
750 0x50, 0xdf, 0x4a, 0xec, 0x71, 0x4f, 0xad, 0x43
756 static struct fips_dev_self_test_vector
757 SELF_TEST_AES256_GCM_encrypt_test_vector = {
758 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
759 .name = "SELF_TEST_AES256_GCM_encrypt_test_vector",
762 0x5c, 0x1b, 0x21, 0xc8, 0x99, 0x8e, 0xd6, 0x29,
763 0x90, 0x06, 0xd3, 0xf9
768 .algo = RTE_CRYPTO_AEAD_AES_GCM,
771 0x22, 0xed, 0x23, 0x59, 0x46, 0x23, 0x5a, 0x85,
772 0xa4, 0x5b, 0xc5, 0xfa, 0xd7, 0x14, 0x0b, 0xfa
779 0xad, 0x42, 0x60, 0xe3, 0xcd, 0xc7, 0x6b, 0xcc,
780 0x10, 0xc7, 0xb2, 0xc0, 0x6b, 0x80, 0xb3, 0xbe,
781 0x94, 0x82, 0x58, 0xe5, 0xef, 0x20, 0xc5, 0x08,
782 0xa8, 0x1f, 0x51, 0xe9, 0x6a, 0x51, 0x83, 0x88
788 0x37, 0xcc, 0xdb, 0xa1, 0xd9, 0x29, 0xd6, 0x43,
789 0x6c, 0x16, 0xbb, 0xa5, 0xb5, 0xff, 0x34, 0xde,
790 0xec, 0x88, 0xed, 0x7d, 0xf3, 0xd1, 0x5d, 0x0f,
791 0x4d, 0xdf, 0x80, 0xc0, 0xc7, 0x31, 0xee, 0x1f
797 0x3b, 0x33, 0x5f, 0x8b, 0x08, 0xd3, 0x3c, 0xcd,
798 0xca, 0xd2, 0x28, 0xa7, 0x47, 0x00, 0xf1, 0x00,
799 0x75, 0x42, 0xa4, 0xd1, 0xe7, 0xfc, 0x1e, 0xbe,
800 0x3f, 0x44, 0x7f, 0xe7, 0x1a, 0xf2, 0x98, 0x16
806 0x1f, 0xbf, 0x49, 0xcc, 0x46, 0xf4, 0x58, 0xbf,
807 0x6e, 0x88, 0xf6, 0x37, 0x09, 0x75, 0xe6, 0xd4
814 /* <-- AES CTR --> */
815 static struct fips_dev_self_test_vector
816 SELF_TEST_AES128_CTR_test_vector = {
817 .name = "SELF_TEST_AES128_CTR_test_vector",
818 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
822 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
823 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
828 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
832 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
833 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
834 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
835 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
841 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
842 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
848 0x87, 0x4D, 0x61, 0x91, 0xB6, 0x20, 0xE3, 0x26,
849 0x1B, 0xEF, 0x68, 0x64, 0x99, 0x0D, 0xB6, 0xCE,
850 0x98, 0x06, 0xF6, 0x6B, 0x79, 0x70, 0xFD, 0xFF,
851 0x86, 0x17, 0x18, 0x7B, 0xB9, 0xFF, 0xFD, 0xFF,
857 static struct fips_dev_self_test_vector
858 SELF_TEST_AES192_CTR_test_vector = {
859 .name = "SELF_TEST_AES192_CTR_test_vector",
860 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
864 0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40,
865 0xB8, 0x7A, 0x4B, 0xED, 0x2B, 0xAF, 0xBF, 0x57
870 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
874 0x01, 0x0F, 0x10, 0x1F, 0x20, 0x1C, 0x0E, 0xB8,
875 0xFB, 0x5C, 0xCD, 0xCC, 0x1F, 0xF9, 0xAF, 0x0B,
876 0x95, 0x03, 0x74, 0x99, 0x49, 0xE7, 0x62, 0x55,
877 0xDA, 0xEA, 0x13, 0x20, 0x1D, 0xC6, 0xCC, 0xCC,
883 0xCB, 0xC5, 0xED, 0x5B, 0xE7, 0x7C, 0xBD, 0x8C,
884 0x50, 0xD9, 0x30, 0xF2, 0xB5, 0x6A, 0x0E, 0x5F,
885 0xAA, 0xAE, 0xAD, 0xA2, 0x1F, 0x49, 0x52, 0xD4
891 0x4A, 0x6C, 0xC8, 0xCC, 0x96, 0x2A, 0x13, 0x84,
892 0x1C, 0x36, 0x88, 0xE9, 0xE5, 0x94, 0x70, 0xB2,
893 0x14, 0x5B, 0x13, 0x80, 0xEA, 0xD8, 0x8D, 0x37,
894 0xFD, 0x70, 0xA8, 0x83, 0xE8, 0x2B, 0x88, 0x1E,
900 static struct fips_dev_self_test_vector
901 SELF_TEST_AES256_CTR_test_vector = {
902 .name = "SELF_TEST_AES256_CTR_test_vector",
903 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
907 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
908 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
913 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
917 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
918 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
919 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
920 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
926 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
927 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
928 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
929 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
935 0x60, 0x1E, 0xC3, 0x13, 0x77, 0x57, 0x89, 0xA5,
936 0xB7, 0xA7, 0xF5, 0x04, 0xBB, 0xF3, 0xD2, 0x28,
937 0xF4, 0x43, 0xE3, 0xCA, 0x4D, 0x62, 0xB5, 0x9A,
938 0xCA, 0x84, 0xE9, 0x90, 0xCA, 0xCA, 0xF5, 0xC5,
945 struct fips_dev_self_test_vector
946 *self_test_vectors[] = {
947 &SELF_TEST_AES128_CBC_test_vector,
948 &SELF_TEST_AES192_CBC_test_vector,
949 &SELF_TEST_AES256_CBC_test_vector,
950 &SELF_TEST_3DES_2KEY_CBC_test_vector,
951 &SELF_TEST_3DES_3KEY_CBC_test_vector,
952 &SELF_TEST_AES128_CCM_test_vector,
953 &SELF_TEST_SHA1_HMAC_test_vector,
954 &SELF_TEST_SHA224_HMAC_test_vector,
955 &SELF_TEST_SHA256_HMAC_test_vector,
956 &SELF_TEST_SHA384_HMAC_test_vector,
957 &SELF_TEST_SHA512_HMAC_test_vector,
958 &SELF_TEST_AES_CMAC_test_vector,
959 &SELF_TEST_AES128_GCM_encrypt_test_vector,
960 &SELF_TEST_AES192_GCM_encrypt_test_vector,
961 &SELF_TEST_AES256_GCM_encrypt_test_vector,
962 &SELF_TEST_AES128_CTR_test_vector,
963 &SELF_TEST_AES192_CTR_test_vector,
964 &SELF_TEST_AES256_CTR_test_vector,
967 struct fips_dev_auto_test_env {
968 struct rte_mempool *mpool;
969 struct rte_mempool *op_pool;
970 struct rte_mempool *sess_pool;
971 struct rte_mempool *sess_priv_pool;
972 struct rte_mbuf *mbuf;
973 struct rte_crypto_op *op;
976 typedef int (*fips_dev_self_test_prepare_xform_t)(uint8_t,
977 struct rte_crypto_sym_xform *,
978 struct fips_dev_self_test_vector *,
982 typedef int (*fips_dev_self_test_prepare_op_t)(struct rte_crypto_op *,
983 struct rte_mbuf *, struct rte_cryptodev_sym_session *,
984 uint32_t, struct fips_dev_self_test_vector *);
986 typedef int (*fips_dev_self_test_check_result_t)(struct rte_crypto_op *,
987 struct fips_dev_self_test_vector *, uint32_t);
989 struct fips_dev_self_test_ops {
990 enum rte_crypto_sym_xform_type last_operation_type;
991 fips_dev_self_test_prepare_xform_t prepare_xform;
992 fips_dev_self_test_prepare_op_t prepare_op;
993 fips_dev_self_test_check_result_t check_result;
997 prepare_cipher_xform(uint8_t dev_id,
998 struct rte_crypto_sym_xform *xform,
999 struct fips_dev_self_test_vector *vec,
1004 const struct rte_cryptodev_symmetric_capability *cap;
1005 struct rte_cryptodev_sym_capability_idx cap_idx;
1006 struct rte_crypto_cipher_xform *cipher_xform = &xform->cipher;
1008 memset(xform, 0, sizeof(*xform));
1010 /** negative test, key is xored */
1014 for (i = 0; i < vec->key.len; i++)
1015 key[i] ^= vec->key.data[i];
1017 memcpy(key, vec->key.data, vec->key.len);
1019 xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1021 cipher_xform->algo = vec->cipher.algo;
1022 cipher_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1023 RTE_CRYPTO_CIPHER_OP_ENCRYPT :
1024 RTE_CRYPTO_CIPHER_OP_DECRYPT;
1025 cipher_xform->key.data = key;
1026 cipher_xform->key.length = vec->key.len;
1027 cipher_xform->iv.length = vec->iv.len;
1028 cipher_xform->iv.offset = IV_OFF;
1030 cap_idx.algo.cipher = cipher_xform->algo;
1031 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1033 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1035 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1040 if (rte_cryptodev_sym_capability_check_cipher(cap,
1041 cipher_xform->key.length,
1042 cipher_xform->iv.length) != 0) {
1043 RTE_LOG(ERR, PMD, "PMD %s key length %u IV length %u\n",
1044 rte_cryptodev_name_get(dev_id),
1045 cipher_xform->key.length,
1046 cipher_xform->iv.length);
1054 prepare_auth_xform(uint8_t dev_id,
1055 struct rte_crypto_sym_xform *xform,
1056 struct fips_dev_self_test_vector *vec,
1061 const struct rte_cryptodev_symmetric_capability *cap;
1062 struct rte_cryptodev_sym_capability_idx cap_idx;
1063 struct rte_crypto_auth_xform *auth_xform = &xform->auth;
1065 memset(xform, 0, sizeof(*xform));
1067 /** negative test, key is xored */
1071 for (i = 0; i < vec->key.len; i++)
1072 key[i] ^= vec->key.data[i];
1074 memcpy(key, vec->key.data, vec->key.len);
1076 xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
1078 auth_xform->algo = vec->auth.algo;
1079 auth_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1080 RTE_CRYPTO_AUTH_OP_GENERATE :
1081 RTE_CRYPTO_AUTH_OP_VERIFY;
1082 auth_xform->digest_length = vec->digest.len;
1083 auth_xform->key.data = key;
1084 auth_xform->key.length = vec->key.len;
1086 cap_idx.algo.auth = auth_xform->algo;
1087 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1089 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1091 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1096 if (rte_cryptodev_sym_capability_check_auth(cap,
1097 auth_xform->key.length,
1098 auth_xform->digest_length, 0) != 0) {
1099 RTE_LOG(ERR, PMD, "PMD %s key length %u Digest length %u\n",
1100 rte_cryptodev_name_get(dev_id),
1101 auth_xform->key.length,
1102 auth_xform->digest_length);
1110 prepare_aead_xform(uint8_t dev_id,
1111 struct rte_crypto_sym_xform *xform,
1112 struct fips_dev_self_test_vector *vec,
1117 const struct rte_cryptodev_symmetric_capability *cap;
1118 struct rte_cryptodev_sym_capability_idx cap_idx;
1119 struct rte_crypto_aead_xform *aead_xform = &xform->aead;
1121 memset(xform, 0, sizeof(*xform));
1123 /** negative test, key is xored */
1127 for (i = 0; i < vec->key.len; i++)
1128 key[i] ^= vec->key.data[i];
1130 memcpy(key, vec->key.data, vec->key.len);
1132 xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
1134 aead_xform->algo = vec->aead.algo;
1135 aead_xform->op = (dir == self_test_dir_enc_auth_gen) ?
1136 RTE_CRYPTO_AEAD_OP_ENCRYPT :
1137 RTE_CRYPTO_AEAD_OP_DECRYPT;
1138 aead_xform->aad_length = vec->aead.aad.len;
1139 aead_xform->digest_length = vec->digest.len;
1140 aead_xform->iv.offset = IV_OFF;
1141 aead_xform->iv.length = vec->iv.len;
1142 aead_xform->key.data = key;
1143 aead_xform->key.length = vec->key.len;
1145 cap_idx.algo.aead = aead_xform->algo;
1146 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
1148 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1150 RTE_LOG(ERR, PMD, "Failed to get capability for cdev %u\n",
1155 if (rte_cryptodev_sym_capability_check_aead(cap,
1156 aead_xform->key.length,
1157 aead_xform->digest_length, aead_xform->aad_length,
1158 aead_xform->iv.length) != 0) {
1160 "PMD %s key_len %u tag_len %u aad_len %u iv_len %u\n",
1161 rte_cryptodev_name_get(dev_id),
1162 aead_xform->key.length,
1163 aead_xform->digest_length,
1164 aead_xform->aad_length,
1165 aead_xform->iv.length);
1173 prepare_cipher_op(struct rte_crypto_op *op,
1174 struct rte_mbuf *mbuf,
1175 struct rte_cryptodev_sym_session *session,
1177 struct fips_dev_self_test_vector *vec)
1179 struct rte_crypto_sym_op *sym = op->sym;
1180 uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1185 if (dir == self_test_dir_enc_auth_gen) {
1186 src = vec->input.data;
1187 len = vec->input.len;
1189 src = vec->output.data;
1190 len = vec->output.len;
1193 sym->cipher.data.offset = 0;
1194 memcpy(iv, vec->iv.data, vec->iv.len);
1196 dst = (uint8_t *)rte_pktmbuf_append(mbuf, len);
1198 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1202 memcpy(dst, src, len);
1204 sym->cipher.data.length = len;
1206 rte_crypto_op_attach_sym_session(op, session);
1212 prepare_auth_op(struct rte_crypto_op *op,
1213 struct rte_mbuf *mbuf,
1214 struct rte_cryptodev_sym_session *session,
1216 struct fips_dev_self_test_vector *vec)
1218 struct rte_crypto_sym_op *sym = op->sym;
1221 if (vec->input.len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1222 RTE_LOG(ERR, PMD, "Error %i: Test data too long (%u).\n",
1223 -ENOMEM, vec->input.len + vec->digest.len);
1227 sym->auth.data.offset = 0;
1229 dst = (uint8_t *)rte_pktmbuf_append(mbuf, vec->input.len +
1232 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1236 memcpy(dst, vec->input.data, vec->input.len);
1237 sym->auth.data.length = vec->input.len;
1238 sym->auth.digest.data = dst + vec->input.len;
1240 if (dir == self_test_dir_dec_auth_verify)
1241 memcpy(dst + vec->input.len, vec->digest.data, vec->digest.len);
1243 rte_crypto_op_attach_sym_session(op, session);
1249 prepare_aead_op(struct rte_crypto_op *op,
1250 struct rte_mbuf *mbuf,
1251 struct rte_cryptodev_sym_session *session,
1253 struct fips_dev_self_test_vector *vec)
1255 struct rte_crypto_sym_op *sym = op->sym;
1256 uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1261 if (dir == self_test_dir_enc_auth_gen) {
1262 len = vec->input.len;
1263 src = vec->input.data;
1265 len = vec->output.len;
1266 src = vec->output.data;
1269 if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
1270 memcpy(iv + 1, vec->iv.data, vec->iv.len);
1272 memcpy(iv, vec->iv.data, vec->iv.len);
1274 if (len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1275 RTE_LOG(ERR, PMD, "Error %i: Test data too long (%u).\n",
1276 -ENOMEM, len + vec->digest.len);
1280 dst = (uint8_t *)rte_pktmbuf_append(mbuf, len + vec->digest.len);
1282 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM);
1287 sym->aead.data.length = len;
1288 sym->aead.data.offset = 0;
1289 sym->aead.aad.data = vec->aead.aad.data;
1290 sym->aead.digest.data = dst + vec->input.len;
1291 memcpy(dst, src, len);
1293 if (dir == self_test_dir_dec_auth_verify)
1294 memcpy(sym->aead.digest.data, vec->digest.data, vec->digest.len);
1296 rte_crypto_op_attach_sym_session(op, session);
1302 check_cipher_result(struct rte_crypto_op *op,
1303 struct fips_dev_self_test_vector *vec,
1306 struct rte_mbuf *mbuf = op->sym->m_src;
1309 uint32_t len, src_len;
1312 if (dir == self_test_dir_enc_auth_gen) {
1313 src = vec->output.data;
1314 src_len = vec->output.len;
1316 src = vec->input.data;
1317 src_len = vec->input.len;
1320 GET_MBUF_DATA(data, len, mbuf);
1324 ret = memcmp(data, src, src_len);
1332 check_auth_result(struct rte_crypto_op *op,
1333 struct fips_dev_self_test_vector *vec,
1336 struct rte_mbuf *mbuf = op->sym->m_src;
1341 GET_MBUF_DATA(data, len, mbuf);
1342 if (len != vec->input.len + vec->digest.len)
1345 if (dir == self_test_dir_enc_auth_gen) {
1346 data += vec->input.len;
1347 ret = memcmp(data, vec->digest.data, vec->digest.len);
1356 check_aead_result(struct rte_crypto_op *op,
1357 struct fips_dev_self_test_vector *vec,
1360 struct rte_mbuf *mbuf = op->sym->m_src;
1363 uint32_t len, src_len;
1366 if (dir == self_test_dir_enc_auth_gen) {
1367 src = vec->output.data;
1368 src_len = vec->output.len;
1370 src = vec->input.data;
1371 src_len = vec->input.len;
1374 GET_MBUF_DATA(data, len, mbuf);
1375 if (len != src_len + vec->digest.len)
1378 ret = memcmp(data, src, src_len);
1382 if (dir == self_test_dir_enc_auth_gen) {
1384 ret = memcmp(data, vec->digest.data, vec->digest.len);
1393 init_test_op(struct fips_dev_self_test_ops *test_ops,
1394 struct fips_dev_self_test_vector *vec)
1396 if (test_ops->last_operation_type == vec->operation_type)
1399 switch (vec->operation_type) {
1400 case RTE_CRYPTO_SYM_XFORM_CIPHER:
1401 test_ops->prepare_xform = prepare_cipher_xform;
1402 test_ops->prepare_op = prepare_cipher_op;
1403 test_ops->check_result = check_cipher_result;
1405 case RTE_CRYPTO_SYM_XFORM_AUTH:
1406 test_ops->prepare_xform = prepare_auth_xform;
1407 test_ops->prepare_op = prepare_auth_op;
1408 test_ops->check_result = check_auth_result;
1410 case RTE_CRYPTO_SYM_XFORM_AEAD:
1411 test_ops->prepare_xform = prepare_aead_xform;
1412 test_ops->prepare_op = prepare_aead_op;
1413 test_ops->check_result = check_aead_result;
1419 test_ops->last_operation_type = vec->operation_type;
1423 run_single_test(uint8_t dev_id,
1424 struct fips_dev_self_test_vector *vec,
1425 const struct fips_dev_self_test_ops *test_ops,
1426 struct fips_dev_auto_test_env *env,
1428 uint32_t negative_test)
1430 struct rte_crypto_sym_xform xform;
1431 struct rte_cryptodev_sym_session *sess;
1436 __rte_crypto_op_reset(env->op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1437 rte_pktmbuf_reset(env->mbuf);
1438 env->op->sym->m_src = env->mbuf;
1440 ret = test_ops->prepare_xform(dev_id, &xform, vec, dir, key,
1443 RTE_LOG(ERR, PMD, "Error %i: Prepare Xform\n", ret);
1447 sess = rte_cryptodev_sym_session_create(env->sess_pool);
1451 ret = rte_cryptodev_sym_session_init(dev_id,
1452 sess, &xform, env->sess_priv_pool);
1454 RTE_LOG(ERR, PMD, "Error %i: Init session\n", ret);
1458 ret = test_ops->prepare_op(env->op, env->mbuf, sess, dir, vec);
1460 RTE_LOG(ERR, PMD, "Error %i: Prepare op\n", ret);
1464 if (rte_cryptodev_enqueue_burst(dev_id, 0, &env->op, 1) < 1) {
1465 RTE_LOG(ERR, PMD, "Error: Failed enqueue\n");
1470 struct rte_crypto_op *deqd_op;
1472 n_deqd = rte_cryptodev_dequeue_burst(dev_id, 0, &deqd_op,
1474 } while (n_deqd == 0);
1476 rte_cryptodev_sym_session_clear(dev_id, sess);
1477 rte_cryptodev_sym_session_free(sess);
1479 if (env->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
1482 return test_ops->check_result(env->op, vec, dir);
1487 fips_dev_auto_test_uninit(uint8_t dev_id,
1488 struct fips_dev_auto_test_env *env)
1490 struct rte_cryptodev *dev = rte_cryptodev_pmd_get_dev(dev_id);
1497 rte_pktmbuf_free(env->mbuf);
1499 rte_crypto_op_free(env->op);
1501 rte_mempool_free(env->mpool);
1503 rte_mempool_free(env->op_pool);
1505 rte_mempool_free(env->sess_pool);
1506 if (env->sess_priv_pool)
1507 rte_mempool_free(env->sess_priv_pool);
1509 if (dev->data->dev_started)
1510 rte_cryptodev_stop(dev_id);
1512 if (dev->data->nb_queue_pairs) {
1513 for (i = 0; i < dev->data->nb_queue_pairs; i++)
1514 (*dev->dev_ops->queue_pair_release)(dev, i);
1515 dev->data->nb_queue_pairs = 0;
1516 rte_free(dev->data->queue_pairs);
1517 dev->data->queue_pairs = NULL;
1522 fips_dev_auto_test_init(uint8_t dev_id, struct fips_dev_auto_test_env *env)
1524 struct rte_cryptodev_config conf = {rte_cryptodev_socket_id(dev_id), 1};
1525 struct rte_cryptodev_qp_conf qp_conf = {128, NULL, NULL};
1526 uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(dev_id);
1530 ret = rte_cryptodev_configure(dev_id, &conf);
1534 memset(name, 0, 128);
1535 snprintf(name, 128, "%s%u", "SELF_TEST_MEMPOOL", dev_id);
1537 memset(env, 0, sizeof(*env));
1539 env->mpool = rte_pktmbuf_pool_create(name, 128, 0, 0,
1540 UINT16_MAX, rte_cryptodev_socket_id(dev_id));
1546 memset(name, 0, 128);
1547 snprintf(name, 128, "%s%u", "SELF_TEST_OP_POOL", dev_id);
1549 env->op_pool = rte_crypto_op_pool_create(
1551 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
1555 if (!env->op_pool) {
1560 memset(name, 0, 128);
1561 snprintf(name, 128, "%s%u", "SELF_TEST_SESS_POOL", dev_id);
1563 env->sess_pool = rte_cryptodev_sym_session_pool_create(name,
1564 128, 0, 0, 0, rte_cryptodev_socket_id(dev_id));
1565 if (!env->sess_pool) {
1570 memset(name, 0, 128);
1571 snprintf(name, 128, "%s%u", "SELF_TEST_SESS_PRIV_POOL", dev_id);
1573 env->sess_priv_pool = rte_mempool_create(name,
1574 128, sess_sz, 0, 0, NULL, NULL, NULL,
1575 NULL, rte_cryptodev_socket_id(dev_id), 0);
1576 if (!env->sess_priv_pool) {
1581 qp_conf.mp_session = env->sess_pool;
1582 qp_conf.mp_session_private = env->sess_priv_pool;
1584 ret = rte_cryptodev_queue_pair_setup(dev_id, 0, &qp_conf,
1585 rte_cryptodev_socket_id(dev_id));
1589 env->mbuf = rte_pktmbuf_alloc(env->mpool);
1595 env->op = rte_crypto_op_alloc(env->op_pool,
1596 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1602 ret = rte_cryptodev_start(dev_id);
1611 fips_dev_auto_test_uninit(dev_id, env);
1617 fips_dev_self_test(uint8_t dev_id,
1618 struct fips_dev_broken_test_config *config)
1620 struct fips_dev_self_test_ops test_ops = {0};
1621 struct fips_dev_auto_test_env env;
1622 uint32_t i, j, negative_test;
1625 ret = fips_dev_auto_test_init(dev_id, &env);
1627 RTE_LOG(ERR, PMD, "Failed to init self-test for PMD %u\n",
1632 for (i = 0; i < RTE_DIM(self_test_vectors); i++) {
1633 struct fips_dev_self_test_vector *vec =
1634 self_test_vectors[i];
1636 init_test_op(&test_ops, vec);
1638 for (j = 0; j < self_test_dir_max; j++) {
1642 if ((config->expect_fail_test_idx == i) &&
1643 (config->expect_fail_dir == j))
1649 RTE_LOG(INFO, PMD, "Testing (ID %u) %s %s%s...\n",
1652 j == self_test_dir_enc_auth_gen ?
1653 "Encrypt" : "Decrypt",
1654 negative_test ? " (Expect Fail)" : "");
1656 ret = run_single_test(dev_id, vec, &test_ops,
1657 &env, j, negative_test);
1663 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1665 j == self_test_dir_enc_auth_gen ?
1666 "Encrypt" : "Decrypt");
1669 RTE_LOG(ERR, PMD, "Not supported by %s. Skip\n",
1670 rte_cryptodev_name_get(dev_id));
1674 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n",
1676 j == self_test_dir_enc_auth_gen ?
1677 "Encrypt" : "Decrypt");
1684 fips_dev_auto_test_uninit(dev_id, &env);
1687 RTE_LOG(INFO, PMD, "PMD %u finished self-test successfully\n",