1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019 Intel Corporation
3 */
4
5 #include <rte_cryptodev.h>
6 #include <rte_malloc.h>
7
8 #include "fips_dev_self_test.h"
9
10 #define IV_OFF (sizeof(struct rte_crypto_op) + sizeof(struct rte_crypto_sym_op))
11
12 #define FIPS_DEV_TEST_DATA_MAX_SIZE 8096
13 #define AES_CCM_AAD_PAD_SIZE 18
14
15 struct fips_dev_self_test_vector {
16 const char *name;
17 enum rte_crypto_sym_xform_type operation_type;
18
19 struct {
20 uint8_t data[64];
21 uint16_t len;
22 } digest;
23
24 struct {
25 uint8_t data[256];
26 uint16_t len;
27 } key;
28
29 struct {
30 uint8_t data[16];
31 uint8_t len;
32 } iv;
33
34 union {
35 struct {
36 enum rte_crypto_cipher_algorithm algo;
37 } cipher;
38
39 struct {
40 enum rte_crypto_aead_algorithm algo;
41 struct {
42 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
43 uint16_t len;
44 } aad;
45 } aead;
46
47 struct {
48 enum rte_crypto_auth_algorithm algo;
49 } auth;
50 };
51
52 struct {
53 const uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
54 uint16_t len;
55 } input;
56
57 struct {
58 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE];
59 uint16_t len;
60 } output;
61 };
62
63 #define GET_MBUF_DATA(data, len, m) \
64 do { \
65 len = rte_pktmbuf_pkt_len(m); \
66 data = rte_pktmbuf_mtod(m, uint8_t *); \
67 } while (0)
68
69
70 /* <-- SHA-x HMAC --> */
71 static struct fips_dev_self_test_vector
72 SELF_TEST_SHA1_HMAC_test_vector = {
73 .name = "SELF_TEST_SHA1_HMAC_test_vector",
74 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
75
76 .auth = {
77 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC,
78 },
79 .input = {
80 .data = {
81 0xed, 0xb2, 0xba, 0x09, 0x99, 0x61, 0xd3, 0x8f,
82 0xd0, 0xa0, 0xa6, 0xa2, 0x35, 0xd6, 0x12, 0x71,
83 0xcb, 0x4d, 0x49, 0x3b, 0x64, 0xd9, 0xde, 0x13,
84 0x5c, 0xbb, 0x1f, 0xe0, 0x86, 0xc4, 0xa4, 0xa7,
85 0x67, 0xbe, 0x28, 0x0d, 0xa2, 0x07, 0x98, 0x17,
86 0xb4, 0x7f, 0x6a, 0x35, 0xe1, 0xa4, 0x30, 0x7f,
87 0x6e, 0xfc, 0x6d, 0x3e, 0x11, 0xb4, 0xa7, 0xae,
88 0xa6, 0x86, 0xbd, 0x02, 0x23, 0xe0, 0x7b, 0xa9,
89 0xce, 0x42, 0x6c, 0xd0, 0xae, 0xe7, 0xef, 0x28,
90 0x3f, 0xa9, 0x8d, 0xe9, 0x6a, 0x1f, 0x8a, 0x17,
91 0xb3, 0x08, 0xba, 0x04, 0xb5, 0xec, 0x96, 0x16,
92 0xcb, 0x00, 0x8f, 0xca, 0x11, 0x4b, 0xa3, 0xf9,
93 0x8b, 0x07, 0x2d, 0x5a, 0xa3, 0x4a, 0x01, 0x49,
94 0xd9, 0xe5, 0xb8, 0xc6, 0xb6, 0x8c, 0x49, 0xc1,
95 0x01, 0x38, 0xda, 0x95, 0x36, 0xca, 0xd5, 0xd2,
96 0x34, 0xf1, 0x3d, 0x3f, 0x36, 0x4d, 0x43, 0x1f
97 },
98 .len = 128,
99 },
100 .key = {
101 .data = {
102 0x8d, 0x8d, 0x15, 0xd8, 0xa9, 0x57, 0x9a, 0xdb,
103 0x2d, 0x62
104 },
105 .len = 10,
106 },
107 .digest = {
108 .data = {
109 0x0c, 0x66, 0x2e, 0x47, 0x93, 0x93, 0x8c, 0xc3,
110 0x7f, 0x3d, 0x51, 0xd2, 0xb4, 0x05, 0x48, 0xec,
111 0x55, 0x91, 0x4f, 0x0d
112 },
113 .len = 20,
114 },
115 };
116
117 static struct fips_dev_self_test_vector
118 SELF_TEST_SHA224_HMAC_test_vector = {
119 .name = "SELF_TEST_SHA224_HMAC_test_vector",
120 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
121 .auth = {
122 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC,
123 },
124 .input = {
125 .data = {
126 0x41, 0x18, 0x43, 0xa2, 0x13, 0x87, 0x84, 0x6f,
127 0x3b, 0x9e, 0xd5, 0xfc, 0x54, 0x5a, 0xca, 0xdf,
128 0xa5, 0xb7, 0x03, 0x86, 0xf6, 0x2d, 0xa4, 0xd9,
129 0xa2, 0x7b, 0x04, 0x1b, 0xee, 0xa3, 0xaa, 0x11,
130 0x99, 0x36, 0x75, 0x67, 0xb4, 0xd1, 0x1a, 0x4f,
131 0xb4, 0xe8, 0xd4, 0x6b, 0xc6, 0xc2, 0x56, 0xed,
132 0x62, 0xc5, 0x05, 0xfd, 0x23, 0xf4, 0x64, 0x5b,
133 0xd6, 0xb6, 0xcf, 0x45, 0xd1, 0xd9, 0x6d, 0x9b,
134 0x86, 0xd6, 0x60, 0x41, 0x57, 0x57, 0x3e, 0xc5,
135 0xac, 0xf6, 0xc5, 0x41, 0x43, 0x48, 0xca, 0x83,
136 0xc8, 0x1a, 0x73, 0x6c, 0xa6, 0xfa, 0xa6, 0x96,
137 0x1c, 0xfa, 0xc1, 0x39, 0x93, 0xb0, 0x8c, 0x50,
138 0x2f, 0x81, 0x6c, 0xf7, 0xa4, 0x20, 0xd9, 0x18,
139 0x4b, 0x51, 0x11, 0x46, 0x75, 0xf3, 0x0e, 0xe9,
140 0xff, 0x3d, 0xb6, 0x9c, 0x26, 0x48, 0x53, 0xd3,
141 0x9d, 0xcd, 0x42, 0xc1, 0xdd, 0x31, 0xef, 0x79
142
143 },
144 .len = 128,
145 },
146 .key = {
147 .data = {
148 0x37, 0x14, 0x70, 0x78, 0x39, 0xda, 0xf7, 0x91,
149 0x22, 0xc7, 0x82, 0x41, 0x63, 0x51, 0x38, 0x5e,
150 0x88, 0xa8, 0x1d, 0x31, 0xc9, 0xf6, 0x41, 0xd8,
151 0xdc, 0xe5, 0x38, 0xe9, 0x0e, 0x63, 0xc9, 0x58,
152 0x92, 0xa2, 0xea, 0x9b, 0x19, 0x62, 0xed, 0x0b,
153 0xa3, 0x72, 0xf4, 0x8e, 0x94, 0x74, 0xaa, 0x73,
154 0x0a, 0xe2
155 },
156 .len = 50,
157 },
158 .digest = {
159 .data = {
160 0x33, 0xf1, 0x7a, 0xc8, 0xa5, 0xc6, 0xb5, 0x25,
161 0xdb, 0x8b, 0x86, 0x44, 0xb6, 0xab
162
163 },
164 .len = 14,
165 },
166 };
167
168
169 static struct fips_dev_self_test_vector
170 SELF_TEST_SHA256_HMAC_test_vector = {
171 .name = "SELF_TEST_SHA256_HMAC_test_vector",
172 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
173 .auth = {
174 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC,
175 },
176 .input = {
177 .data = {
178 0x1c, 0x43, 0x96, 0xf7, 0xb7, 0xf9, 0x22, 0x8e,
179 0x83, 0x2a, 0x13, 0x69, 0x20, 0x02, 0xba, 0x2a,
180 0xff, 0x43, 0x9d, 0xcb, 0x7f, 0xdd, 0xbf, 0xd4,
181 0x56, 0xc0, 0x22, 0xd1, 0x33, 0xee, 0x89, 0x03,
182 0xa2, 0xd4, 0x82, 0x56, 0x2f, 0xda, 0xa4, 0x93,
183 0xce, 0x39, 0x16, 0xd7, 0x7a, 0x0c, 0x51, 0x44,
184 0x1d, 0xab, 0x26, 0xf6, 0xb0, 0x34, 0x02, 0x38,
185 0xa3, 0x6a, 0x71, 0xf8, 0x7f, 0xc3, 0xe1, 0x79,
186 0xca, 0xbc, 0xa9, 0x48, 0x2b, 0x70, 0x49, 0x71,
187 0xce, 0x69, 0xf3, 0xf2, 0x0a, 0xb6, 0x4b, 0x70,
188 0x41, 0x3d, 0x6c, 0x29, 0x08, 0x53, 0x2b, 0x2a,
189 0x88, 0x8a, 0x9f, 0xc2, 0x24, 0xca, 0xe1, 0x36,
190 0x5d, 0xa4, 0x10, 0xb6, 0xf2, 0xe2, 0x98, 0x90,
191 0x4b, 0x63, 0xb4, 0xa4, 0x17, 0x26, 0x32, 0x18,
192 0x35, 0xa4, 0x77, 0x4d, 0xd0, 0x63, 0xc2, 0x11,
193 0xcf, 0xc8, 0xb5, 0x16, 0x6c, 0x2d, 0x11, 0xa2
194 },
195 .len = 128,
196 },
197 .key = {
198 .data = {
199 0x54, 0x48, 0x99, 0x8f, 0x9d, 0x8f, 0x98, 0x53,
200 0x4a, 0xdd, 0xf0, 0xc8, 0xba, 0x63, 0x1c, 0x49,
201 0x6b, 0xf8, 0xa8, 0x00, 0x6c, 0xbb, 0x46, 0xad,
202 0x15, 0xfa, 0x1f, 0xa2, 0xf5, 0x53, 0x67, 0x12,
203 0x0c, 0x19, 0x34, 0x8c, 0x3a, 0xfa, 0x90, 0xc3
204 },
205 .len = 40,
206 },
207 .digest = {
208 .data = {
209 0x7e, 0x8c, 0xba, 0x9d, 0xd9, 0xf0, 0x6e, 0xbd,
210 0xd7, 0xf9, 0x2e, 0x0f, 0x1a, 0x67, 0xc7, 0xf4,
211 0xdf, 0x52, 0x69, 0x3c, 0x21, 0x2b, 0xdd, 0x84,
212 0xf6, 0x73, 0x70, 0xb3, 0x51, 0x53, 0x3c, 0x6c
213 },
214 .len = 32,
215 },
216 };
217
218 /* HMAC count=34 L=48 SHA384 GENERATE*/
219 static struct fips_dev_self_test_vector
220 SELF_TEST_SHA384_HMAC_test_vector = {
221 .name = "SELF_TEST_SHA384_HMAC_test_vector",
222 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
223 .auth = {
224 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC,
225 },
226 .input = {
227 .data = {
228 0xf5, 0x10, 0x86, 0xfe, 0x78, 0x15, 0x0f, 0xe4,
229 0x8b, 0xd1, 0x41, 0x5a, 0x47, 0x85, 0xac, 0xc0,
230 0x5a, 0xb8, 0x0e, 0xf0, 0x0b, 0x29, 0x75, 0xce,
231 0x78, 0x07, 0xa4, 0x21, 0x22, 0x64, 0xb8, 0xa1,
232 0xac, 0xe8, 0x0b, 0x50, 0xe0, 0xc2, 0x59, 0x0e,
233 0xf3, 0xe4, 0x21, 0x68, 0x0a, 0x70, 0x4e, 0xb2,
234 0xfc, 0x6d, 0x17, 0x55, 0x5a, 0xbf, 0x24, 0x69,
235 0xad, 0x56, 0xf2, 0x87, 0xfe, 0xa5, 0x78, 0xd8,
236 0x9c, 0x56, 0x0b, 0x72, 0x19, 0x3c, 0x7f, 0xe5,
237 0x96, 0x89, 0x8f, 0x10, 0x40, 0x41, 0x7e, 0x3a,
238 0x1b, 0xee, 0xff, 0x5e, 0xff, 0x96, 0x53, 0xc5,
239 0xe0, 0xea, 0xb1, 0xda, 0x52, 0xc0, 0xea, 0x3b,
240 0x4b, 0xc3, 0x4d, 0x0c, 0x2b, 0x69, 0xc8, 0x90,
241 0xfb, 0x26, 0x51, 0xfa, 0xf2, 0xe0, 0x84, 0x80,
242 0x3e, 0xa2, 0x8e, 0xb2, 0x01, 0x94, 0x49, 0x0a,
243 0x99, 0x2b, 0xa8, 0xc4, 0x24, 0x9d, 0x56, 0xef
244 },
245 .len = 128,
246 },
247 .key = {
248 .data = {
249 0x91, 0x7a, 0x69, 0x8c, 0x82, 0xf4, 0x4f, 0x19,
250 0x57, 0x3b, 0x64, 0x5c, 0x48, 0x79, 0xb8, 0x73,
251 0x0b, 0x58, 0xdf, 0xf4, 0xed, 0xc6, 0xa0, 0xd3,
252 0x21, 0xf5, 0xf1, 0x86, 0x58, 0xa5, 0x24, 0x66,
253 0x92, 0xa5, 0x5b, 0x59, 0x33, 0x97, 0x41, 0xae,
254 0x59, 0xf5, 0xfc, 0x48, 0x6d, 0x51, 0x5d, 0xff,
255 0xf8, 0xe1
256 },
257 .len = 50,
258 },
259 .digest = {
260 .data = {
261 0x77, 0xbf, 0x56, 0x15, 0xec, 0x52, 0xf7, 0x06,
262 0xca, 0x74, 0x64, 0x01, 0xe9, 0xfd, 0xe4, 0x3f,
263 0x15, 0x60, 0x52, 0x37, 0xe5, 0x50, 0xb9, 0x3a,
264 0x84, 0x72, 0xfd, 0x14, 0x4f, 0xc3, 0x9e, 0x5e,
265 0xca, 0x0f, 0xe8, 0x90, 0x83, 0x88, 0x28, 0xa0
266 },
267 .len = 40,
268 },
269 };
270
271 /* HMAC count=28 L=64 SHA512 GENERATE*/
272 static struct fips_dev_self_test_vector
273 SELF_TEST_SHA512_HMAC_test_vector = {
274 .name = "SELF_TEST_SHA512_HMAC_test_vector",
275 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
276 .auth = {
277 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC,
278 },
279 .input = {
280 .data = {
281 0x0a, 0x33, 0x1c, 0xe2, 0x00, 0x89, 0xb2, 0x9e,
282 0x94, 0xb2, 0xc5, 0xf5, 0x18, 0xc8, 0xdb, 0xea,
283 0xd4, 0x04, 0x17, 0xa2, 0xa8, 0xd5, 0x00, 0x18,
284 0xf3, 0x2f, 0x85, 0x12, 0xb3, 0x26, 0x3d, 0x54,
285 0xed, 0xbb, 0xf3, 0x13, 0x4f, 0xf6, 0x61, 0xac,
286 0x14, 0x35, 0x3c, 0x96, 0x28, 0xc3, 0x71, 0x95,
287 0x8c, 0xac, 0xaf, 0x31, 0xfd, 0xd0, 0x25, 0x67,
288 0xd0, 0x37, 0x8d, 0x9e, 0x21, 0xa4, 0x69, 0xdd,
289 0x2c, 0x6d, 0x8c, 0x3a, 0xfb, 0x89, 0xdd, 0x96,
290 0x42, 0xeb, 0x58, 0x87, 0x87, 0x0e, 0x55, 0x96,
291 0x85, 0xd2, 0x0d, 0xab, 0xd3, 0x86, 0x5a, 0xc5,
292 0xc1, 0x46, 0xbe, 0xee, 0x83, 0x87, 0xa7, 0x6f,
293 0x91, 0xf0, 0xf1, 0x40, 0x4d, 0x6c, 0xad, 0xc2,
294 0xe6, 0x7d, 0x21, 0xb0, 0x7d, 0xd3, 0x0f, 0x53,
295 0x87, 0x1d, 0x3b, 0xf6, 0x73, 0x1f, 0x27, 0x9a,
296 0x8c, 0x04, 0x21, 0xeb, 0x20, 0xf6, 0x7f, 0x72
297 },
298 .len = 128,
299 },
300 .key = {
301 .data = {
302 0x39, 0xb8, 0x77, 0xb8, 0xe8, 0x2e, 0xcb, 0xd9,
303 0x74, 0x03, 0x25, 0x82, 0x8f, 0xaf, 0x67, 0x21,
304 0xc1, 0x29, 0x04, 0x6e, 0xb0, 0x13, 0x61, 0x44,
305 0xa0, 0x31, 0x82, 0xb1, 0x36, 0x20, 0xe2, 0x49,
306 0x81, 0x45, 0xa2, 0xbf, 0x3b, 0x03, 0xe6, 0xb6,
307 0x4b, 0x31, 0x7d, 0xd4, 0x8f, 0xcb, 0xc0, 0x18,
308 0xd9, 0xe7, 0xbc, 0x6e, 0x37, 0xeb, 0x93, 0x81,
309 0x78, 0xfe, 0x1f, 0xd1, 0xeb, 0xbc, 0xd9, 0x05,
310 0x6a, 0x2e, 0xf9, 0x82, 0x97, 0xf9, 0xdf, 0x3c,
311 0x66, 0xd5, 0xb2, 0xcc, 0xdc, 0x41, 0x47, 0xc4,
312 0x16, 0x76, 0x44, 0x3f, 0x8c, 0x99, 0x85, 0xbc,
313 0x97, 0x34, 0xbe, 0x2c, 0x31, 0xe7, 0x62, 0x49,
314 0xfc, 0x5b, 0xc4, 0x2a
315 },
316 .len = 100,
317 },
318 .digest = {
319 .data = {
320 0x97, 0x16, 0x8f, 0x55, 0x13, 0xc2, 0xe9, 0xbc,
321 0x4b, 0xc5, 0x25, 0xce, 0x27, 0x03, 0x74, 0x0b,
322 0xce, 0x1a, 0x06, 0xec, 0xfe, 0x99, 0xa5, 0x70,
323 0xac, 0x66, 0xc8, 0x3e, 0xde, 0x96, 0x67, 0xcc,
324 0x07, 0xed, 0xf6, 0x64, 0x61, 0x7c, 0xe5, 0x3c
325 },
326 .len = 40,
327 },
328 };
329
330 /* <-- AES CMAC --> */
331 static struct fips_dev_self_test_vector
332 SELF_TEST_AES_CMAC_test_vector = {
333 .name = "SELF_TEST_AES_CMAC_test_vector",
334 .operation_type = RTE_CRYPTO_SYM_XFORM_AUTH,
335 .auth = {
336 .algo = RTE_CRYPTO_AUTH_AES_CMAC,
337 },
338 .input = {
339 .data = {
340 0x57, 0x88, 0xf6, 0x1e, 0x02, 0x30, 0x47, 0x91,
341 0xb5, 0x2f, 0x40, 0x05, 0x7a, 0xbb, 0x4e, 0x04,
342 0x46, 0x40, 0x3e, 0xf3, 0x74, 0x02, 0x53, 0xdf,
343 0x72, 0x05, 0x96, 0x79, 0xbb, 0x2a, 0x6e, 0x5e,
344 0x05, 0x9a, 0x70, 0x9c, 0xbb
345 },
346 .len = 37,
347 },
348 .key = {
349 .data = {
350 0x18, 0x42, 0x15, 0x14, 0x5d, 0xa4, 0x9d, 0xb4,
351 0x17, 0xe8, 0xbd, 0xd5, 0x73, 0xd6, 0x28, 0x2d
352 },
353 .len = 16,
354 },
355 .digest = {
356 .data = {
357 0x8d, 0xa8, 0xcc, 0xa9, 0xb3, 0x6f, 0x68, 0x57,
358 0x1c, 0x6c, 0x0e, 0x40, 0xa3, 0xf4, 0x10
359 },
360 .len = 15,
361 },
362 };
363
364 /* <-- AES CCM --> */
365 static struct fips_dev_self_test_vector
366 SELF_TEST_AES128_CCM_test_vector = {
367 .name = "SELF_TEST_AES128_CCM_test_vector",
368 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
369 .iv = {
370 .data = {
371 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5,
372 0x03, 0x97, 0x76, 0xE7, 0x0C
373 },
374 .len = 13,
375 },
376 .aead = {
377 .algo = RTE_CRYPTO_AEAD_AES_CCM,
378 .aad = {
379 .data = {
380 /* 18 bytes padding for AAD */
381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
382 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
383 0x00, 0x00,
384 0x08, 0x40, 0x0F, 0xD2, 0xE1, 0x28, 0xA5, 0x7C,
385 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xAB, 0xAE,
386 0xA5, 0xB8, 0xFC, 0xBA, 0x00, 0x00
387 },
388 .len = 22,
389 },
390 },
391 .input = {
392 .data = {
393 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE,
394 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB,
395 0x7E, 0x78, 0xA0, 0x50
396 },
397 .len = 20,
398 },
399 .key = {
400 .data = {
401 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85,
402 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F
403 },
404 .len = 16,
405 },
406 .output = {
407 .data = {
408 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23,
409 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C,
410 0x3C, 0x04, 0xD0, 0x19
411 },
412 .len = 20,
413 },
414 .digest = {
415 .data = {
416 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23
417 },
418 .len = 8,
419 },
420 };
421
422 /* <-- AES CBC --> */
423 static struct fips_dev_self_test_vector
424 SELF_TEST_AES128_CBC_test_vector = {
425 .name = "SELF_TEST_AES128_CBC_test_vector",
426 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
427
428 .iv = {
429 .data = {
430 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
431 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
432 },
433 .len = 16,
434 },
435 .cipher = {
436 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
437 },
438 .input = {
439 .data = {
440 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
441 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
442 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
443 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
444 },
445 .len = 32,
446 },
447 .key = {
448 .data = {
449 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
450 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A
451 },
452 .len = 16,
453 },
454 .output = {
455 .data = {
456 0x8B, 0x4D, 0xDA, 0x1B, 0xCF, 0x04, 0xA0, 0x31,
457 0xB4, 0xBF, 0xBD, 0x68, 0x43, 0x20, 0x7E, 0x76,
458 0xB1, 0x96, 0x8B, 0xA2, 0x7C, 0xA2, 0x83, 0x9E,
459 0x39, 0x5A, 0x2F, 0x7E, 0x92, 0xB4, 0x48, 0x1A,
460 },
461 .len = 32,
462 },
463 };
464
465 static struct fips_dev_self_test_vector
466 SELF_TEST_AES192_CBC_test_vector = {
467 .name = "SELF_TEST_AES192_CBC_test_vector",
468 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
469
470 .iv = {
471 .data = {
472 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
473 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
474 },
475 .len = 16,
476 },
477 .cipher = {
478 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
479 },
480 .input = {
481 .data = {
482 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
483 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
484 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
485 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
486 },
487 .len = 32,
488 },
489 .key = {
490 .data = {
491 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
492 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
493 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
494 },
495 .len = 24,
496 },
497 .output = {
498 .data = {
499 0x45, 0xEE, 0x9A, 0xEA, 0x3C, 0x03, 0xFC, 0x4C,
500 0x84, 0x36, 0xB0, 0xDA, 0xB0, 0xDC, 0xF3, 0x5B,
501 0x75, 0xA7, 0xBE, 0x0E, 0xC0, 0x8D, 0x6C, 0xF8,
502 0xC1, 0x0F, 0xD0, 0x35, 0x1D, 0x82, 0xAE, 0x7C,
503 },
504 .len = 32,
505 },
506 };
507
508 /* AES-256 CBC ENCRYPT*/
509 static struct fips_dev_self_test_vector
510 SELF_TEST_AES256_CBC_test_vector = {
511 .name = "SELF_TEST_AES256_CBC_test_vector",
512 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
513
514 .iv = {
515 .data = {
516 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
517 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
518 },
519 .len = 16,
520 },
521 .cipher = {
522 .algo = RTE_CRYPTO_CIPHER_AES_CBC,
523 },
524 .input = {
525 .data = {
526 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
527 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
528 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
529 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
530 },
531 .len = 32,
532 },
533 .key = {
534 .data = {
535 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
536 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
537 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0,
538 0x37, 0x07, 0xB8, 0x23, 0xA2, 0xA3, 0xB5, 0x8D
539 },
540 .len = 32,
541 },
542 .output = {
543 .data = {
544 0xF3, 0xDD, 0xF0, 0x0B, 0xFF, 0xA2, 0x6A, 0x04,
545 0xBE, 0xDA, 0x52, 0xA6, 0xFE, 0x6B, 0xA6, 0xA7,
546 0x48, 0x1D, 0x7D, 0x98, 0x65, 0xDB, 0xEF, 0x06,
547 0x26, 0xB5, 0x8E, 0xEB, 0x05, 0x0E, 0x77, 0x98,
548 },
549 .len = 32,
550 },
551 };
552
553 /* DES-128 CBC ENCRYPT*/
554 static struct fips_dev_self_test_vector
555 SELF_TEST_3DES_2KEY_CBC_test_vector = {
556 .name = "SELF_TEST_3DES_2KEY_CBC_test_vector",
557 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
558 .iv = {
559 .data = {
560 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
561 },
562 .len = 8,
563 },
564 .cipher = {
565 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
566 },
567 .input = {
568 .data = {
569 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
570 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
571 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
572 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
573 },
574 .len = 32,
575 },
576 .key = {
577 .data = {
578 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
579 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
580 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2
581 },
582 .len = 24,
583 },
584 .output = {
585 .data = {
586 0x28, 0x2a, 0xff, 0x15, 0x5c, 0xdf, 0xd9, 0x6b,
587 0x54, 0xbc, 0x7b, 0xfb, 0xc5, 0x64, 0x4d, 0xdd,
588 0x3e, 0xf2, 0x9e, 0xb7, 0x53, 0x65, 0x37, 0x05,
589 0xe0, 0xdf, 0xae, 0xf7, 0xc9, 0x27, 0xe4, 0xec,
590 },
591 .len = 32,
592 },
593 };
594
595 static struct fips_dev_self_test_vector
596 SELF_TEST_3DES_3KEY_CBC_test_vector = {
597 .name = "SELF_TEST_3DES_3KEY_CBC_test_vector",
598 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
599
600 .iv = {
601 .data = {
602 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07
603 },
604 .len = 8,
605 },
606 .cipher = {
607 .algo = RTE_CRYPTO_CIPHER_3DES_CBC,
608 },
609 .input = {
610 .data = {
611 0x57, 0x68, 0x61, 0x74, 0x20, 0x61, 0x20, 0x6C,
612 0x6F, 0x75, 0x73, 0x79, 0x20, 0x65, 0x61, 0x72,
613 0x74, 0x68, 0x21, 0x20, 0x48, 0x65, 0x20, 0x77,
614 0x6F, 0x6E, 0x64, 0x65, 0x72, 0x65, 0x64, 0x20,
615 },
616 .len = 32,
617 },
618 .key = {
619 .data = {
620 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2,
621 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A,
622 0xD4, 0xC3, 0xA3, 0xAA, 0x33, 0x62, 0x61, 0xE0
623 },
624 .len = 24,
625 },
626 .output = {
627 .data = {
628 0xd0, 0xc9, 0xdc, 0x51, 0x29, 0x97, 0x03, 0x64,
629 0xcd, 0x22, 0xba, 0x3d, 0x2b, 0xbc, 0x21, 0x37,
630 0x7b, 0x1e, 0x29, 0x23, 0xeb, 0x51, 0x6e, 0xac,
631 0xbe, 0x5b, 0xd3, 0x67, 0xe0, 0x3f, 0xc3, 0xb5,
632 },
633 .len = 32,
634 },
635 };
636
637 /* <-- AES GCM --> */
638 static struct fips_dev_self_test_vector
639 SELF_TEST_AES128_GCM_encrypt_test_vector = {
640 .name = "SELF_TEST_AES128_GCM_encrypt_test_vector",
641 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
642
643 .iv = {
644 .data = {
645 0x5a, 0xdb, 0x96, 0x09, 0xdb, 0xae, 0xb5, 0x8c,
646 0xbd, 0x6e, 0x72, 0x75
647 },
648 .len = 12,
649 },
650 .aead = {
651 .algo = RTE_CRYPTO_AEAD_AES_GCM,
652 .aad = {
653 .data = {
654 0x88, 0x31, 0x9d, 0x6e, 0x1d, 0x3f, 0xfa, 0x5f,
655 0x98, 0x71, 0x99, 0x16, 0x6c, 0x8a, 0x9b, 0x56,
656 0xc2, 0xae, 0xba, 0x5a
657 },
658 .len = 20,
659 },
660 },
661 .input = {
662 .data = {
663 0x7c, 0x0e, 0x88, 0xc8, 0x88, 0x99, 0xa7, 0x79,
664 0x22, 0x84, 0x65, 0x07, 0x47, 0x97, 0xcd, 0x4c,
665 0x2e, 0x14, 0x98, 0xd2, 0x59, 0xb5, 0x43, 0x90,
666 0xb8, 0x5e, 0x3e, 0xef, 0x1c, 0x02, 0xdf, 0x60,
667 0xe7, 0x43, 0xf1, 0xb8, 0x40, 0x38, 0x2c, 0x4b,
668 0xcc, 0xaf, 0x3b, 0xaf, 0xb4, 0xca, 0x84, 0x29,
669 0xbe, 0xa0, 0x63
670 },
671 .len = 51,
672 },
673 .key = {
674 .data = {
675 0xfe, 0x47, 0xfc, 0xce, 0x5f, 0xc3, 0x26, 0x65,
676 0xd2, 0xae, 0x39, 0x9e, 0x4e, 0xec, 0x72, 0xba
677 },
678 .len = 16,
679 },
680 .output = {
681 .data = {
682 0x98, 0xf4, 0x82, 0x6f, 0x05, 0xa2, 0x65, 0xe6,
683 0xdd, 0x2b, 0xe8, 0x2d, 0xb2, 0x41, 0xc0, 0xfb,
684 0xbb, 0xf9, 0xff, 0xb1, 0xc1, 0x73, 0xaa, 0x83,
685 0x96, 0x4b, 0x7c, 0xf5, 0x39, 0x30, 0x43, 0x73,
686 0x63, 0x65, 0x25, 0x3d, 0xdb, 0xc5, 0xdb, 0x87,
687 0x78, 0x37, 0x14, 0x95, 0xda, 0x76, 0xd2, 0x69,
688 0xe5, 0xdb, 0x3e
689 },
690 .len = 51,
691 },
692 .digest = {
693 .data = {
694 0x29, 0x1e, 0xf1, 0x98, 0x2e, 0x4d, 0xef, 0xed,
695 0xaa, 0x22, 0x49, 0xf8, 0x98, 0x55, 0x6b, 0x47
696 },
697 .len = 16,
698 },
699 };
700
701 static struct fips_dev_self_test_vector
702 SELF_TEST_AES192_GCM_encrypt_test_vector = {
703 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
704 .name = "SELF_TEST_AES192_GCM_encrypt_test_vector",
705 .iv = {
706 .data = {
707 0x0b, 0xd4, 0x4f, 0xf4, 0xd2, 0x0c, 0x15, 0xd0,
708 0x4f, 0xc6, 0x1e, 0xe7
709 },
710 .len = 12,
711 },
712 .aead = {
713 .algo = RTE_CRYPTO_AEAD_AES_GCM,
714 .aad = {
715 .data = {
716 0x9e, 0xa4, 0x2c, 0x50, 0xa7, 0xfd, 0xb8, 0x5e,
717 0x14, 0x1a, 0xa0, 0x84, 0xb4, 0x6b, 0xde, 0x12
718 },
719 .len = 16,
720 },
721 },
722 .input = {
723 .data = {
724 0x56, 0x7c, 0xcb, 0x3f, 0xa0, 0xdb, 0x89, 0x70,
725 0x8a, 0xf3, 0xff, 0x2b, 0xb0, 0x29, 0xdd, 0xec,
726 0x52, 0xc6, 0x69, 0x47, 0x58, 0x5d, 0x29, 0x1a,
727 0x28, 0x56, 0x4b, 0xf5, 0x6d, 0xb7, 0x06, 0xf7
728 },
729 .len = 32,
730 },
731 .key = {
732 .data = {
733 0x0d, 0x4a, 0x90, 0x0d, 0x1b, 0x0b, 0xb5, 0xb7,
734 0xbe, 0x24, 0x38, 0xc2, 0xba, 0x48, 0xfc, 0x45,
735 0x13, 0x4c, 0xc1, 0x98, 0x10, 0x8c, 0xf8, 0x85
736 },
737 .len = 24,
738 },
739 .output = {
740 .data = {
741 0x2f, 0x8a, 0x42, 0xcd, 0x18, 0x3b, 0x03, 0x14,
742 0xfd, 0x20, 0xa3, 0xd9, 0x7d, 0x9e, 0x0c, 0x52,
743 0x17, 0xb0, 0xf0, 0x88, 0xd2, 0xca, 0x87, 0xa8,
744 0x29, 0x0d, 0x4b, 0xae, 0x69, 0xad, 0x83, 0xf5
745 },
746 .len = 32,
747 },
748 .digest = {
749 .data = {
750 0xde, 0x41, 0x45, 0x92, 0xd7, 0x7f, 0x2f, 0x0b,
751 0x50, 0xdf, 0x4a, 0xec, 0x71, 0x4f, 0xad, 0x43
752 },
753 .len = 16,
754 },
755 };
756
757 static struct fips_dev_self_test_vector
758 SELF_TEST_AES256_GCM_encrypt_test_vector = {
759 .operation_type = RTE_CRYPTO_SYM_XFORM_AEAD,
760 .name = "SELF_TEST_AES256_GCM_encrypt_test_vector",
761 .iv = {
762 .data = {
763 0x5c, 0x1b, 0x21, 0xc8, 0x99, 0x8e, 0xd6, 0x29,
764 0x90, 0x06, 0xd3, 0xf9
765 },
766 .len = 12,
767 },
768 .aead = {
769 .algo = RTE_CRYPTO_AEAD_AES_GCM,
770 .aad = {
771 .data = {
772 0x22, 0xed, 0x23, 0x59, 0x46, 0x23, 0x5a, 0x85,
773 0xa4, 0x5b, 0xc5, 0xfa, 0xd7, 0x14, 0x0b, 0xfa
774 },
775 .len = 16,
776 },
777 },
778 .input = {
779 .data = {
780 0xad, 0x42, 0x60, 0xe3, 0xcd, 0xc7, 0x6b, 0xcc,
781 0x10, 0xc7, 0xb2, 0xc0, 0x6b, 0x80, 0xb3, 0xbe,
782 0x94, 0x82, 0x58, 0xe5, 0xef, 0x20, 0xc5, 0x08,
783 0xa8, 0x1f, 0x51, 0xe9, 0x6a, 0x51, 0x83, 0x88
784 },
785 .len = 32,
786 },
787 .key = {
788 .data = {
789 0x37, 0xcc, 0xdb, 0xa1, 0xd9, 0x29, 0xd6, 0x43,
790 0x6c, 0x16, 0xbb, 0xa5, 0xb5, 0xff, 0x34, 0xde,
791 0xec, 0x88, 0xed, 0x7d, 0xf3, 0xd1, 0x5d, 0x0f,
792 0x4d, 0xdf, 0x80, 0xc0, 0xc7, 0x31, 0xee, 0x1f
793 },
794 .len = 32,
795 },
796 .output = {
797 .data = {
798 0x3b, 0x33, 0x5f, 0x8b, 0x08, 0xd3, 0x3c, 0xcd,
799 0xca, 0xd2, 0x28, 0xa7, 0x47, 0x00, 0xf1, 0x00,
800 0x75, 0x42, 0xa4, 0xd1, 0xe7, 0xfc, 0x1e, 0xbe,
801 0x3f, 0x44, 0x7f, 0xe7, 0x1a, 0xf2, 0x98, 0x16
802 },
803 .len = 32,
804 },
805 .digest = {
806 .data = {
807 0x1f, 0xbf, 0x49, 0xcc, 0x46, 0xf4, 0x58, 0xbf,
808 0x6e, 0x88, 0xf6, 0x37, 0x09, 0x75, 0xe6, 0xd4
809 },
810 .len = 16,
811 },
812 };
813
814
815 /* <-- AES CTR --> */
816 static struct fips_dev_self_test_vector
817 SELF_TEST_AES128_CTR_test_vector = {
818 .name = "SELF_TEST_AES128_CTR_test_vector",
819 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
820
821 .iv = {
822 .data = {
823 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
824 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
825 },
826 .len = 16,
827 },
828 .cipher = {
829 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
830 },
831 .input = {
832 .data = {
833 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
834 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
835 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
836 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
837 },
838 .len = 32,
839 },
840 .key = {
841 .data = {
842 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6,
843 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C
844 },
845 .len = 16,
846 },
847 .output = {
848 .data = {
849 0x87, 0x4D, 0x61, 0x91, 0xB6, 0x20, 0xE3, 0x26,
850 0x1B, 0xEF, 0x68, 0x64, 0x99, 0x0D, 0xB6, 0xCE,
851 0x98, 0x06, 0xF6, 0x6B, 0x79, 0x70, 0xFD, 0xFF,
852 0x86, 0x17, 0x18, 0x7B, 0xB9, 0xFF, 0xFD, 0xFF,
853 },
854 .len = 32,
855 },
856 };
857
858 static struct fips_dev_self_test_vector
859 SELF_TEST_AES192_CTR_test_vector = {
860 .name = "SELF_TEST_AES192_CTR_test_vector",
861 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
862
863 .iv = {
864 .data = {
865 0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40,
866 0xB8, 0x7A, 0x4B, 0xED, 0x2B, 0xAF, 0xBF, 0x57
867 },
868 .len = 16,
869 },
870 .cipher = {
871 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
872 },
873 .input = {
874 .data = {
875 0x01, 0x0F, 0x10, 0x1F, 0x20, 0x1C, 0x0E, 0xB8,
876 0xFB, 0x5C, 0xCD, 0xCC, 0x1F, 0xF9, 0xAF, 0x0B,
877 0x95, 0x03, 0x74, 0x99, 0x49, 0xE7, 0x62, 0x55,
878 0xDA, 0xEA, 0x13, 0x20, 0x1D, 0xC6, 0xCC, 0xCC,
879 },
880 .len = 32,
881 },
882 .key = {
883 .data = {
884 0xCB, 0xC5, 0xED, 0x5B, 0xE7, 0x7C, 0xBD, 0x8C,
885 0x50, 0xD9, 0x30, 0xF2, 0xB5, 0x6A, 0x0E, 0x5F,
886 0xAA, 0xAE, 0xAD, 0xA2, 0x1F, 0x49, 0x52, 0xD4
887 },
888 .len = 24,
889 },
890 .output = {
891 .data = {
892 0x4A, 0x6C, 0xC8, 0xCC, 0x96, 0x2A, 0x13, 0x84,
893 0x1C, 0x36, 0x88, 0xE9, 0xE5, 0x94, 0x70, 0xB2,
894 0x14, 0x5B, 0x13, 0x80, 0xEA, 0xD8, 0x8D, 0x37,
895 0xFD, 0x70, 0xA8, 0x83, 0xE8, 0x2B, 0x88, 0x1E,
896 },
897 .len = 32,
898 },
899 };
900
901 static struct fips_dev_self_test_vector
902 SELF_TEST_AES256_CTR_test_vector = {
903 .name = "SELF_TEST_AES256_CTR_test_vector",
904 .operation_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
905
906 .iv = {
907 .data = {
908 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
909 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF
910 },
911 .len = 16,
912 },
913 .cipher = {
914 .algo = RTE_CRYPTO_CIPHER_AES_CTR,
915 },
916 .input = {
917 .data = {
918 0x6B, 0xC1, 0xBE, 0xE2, 0x2E, 0x40, 0x9F, 0x96,
919 0xE9, 0x3D, 0x7E, 0x11, 0x73, 0x93, 0x17, 0x2A,
920 0xAE, 0x2D, 0x8A, 0x57, 0x1E, 0x03, 0xAC, 0x9C,
921 0x9E, 0xB7, 0x6F, 0xAC, 0x45, 0xAF, 0x8E, 0x51,
922 },
923 .len = 32,
924 },
925 .key = {
926 .data = {
927 0x60, 0x3D, 0xEB, 0x10, 0x15, 0xCA, 0x71, 0xBE,
928 0x2B, 0x73, 0xAE, 0xF0, 0x85, 0x7D, 0x77, 0x81,
929 0x1F, 0x35, 0x2C, 0x07, 0x3B, 0x61, 0x08, 0xD7,
930 0x2D, 0x98, 0x10, 0xA3, 0x09, 0x14, 0xDF, 0xF4
931 },
932 .len = 32,
933 },
934 .output = {
935 .data = {
936 0x60, 0x1E, 0xC3, 0x13, 0x77, 0x57, 0x89, 0xA5,
937 0xB7, 0xA7, 0xF5, 0x04, 0xBB, 0xF3, 0xD2, 0x28,
938 0xF4, 0x43, 0xE3, 0xCA, 0x4D, 0x62, 0xB5, 0x9A,
939 0xCA, 0x84, 0xE9, 0x90, 0xCA, 0xCA, 0xF5, 0xC5,
940 },
941 .len = 32,
942 },
943 };
944
945
946 struct fips_dev_self_test_vector
947 *self_test_vectors[] = {
948 &SELF_TEST_AES128_CBC_test_vector,
949 &SELF_TEST_AES192_CBC_test_vector,
950 &SELF_TEST_AES256_CBC_test_vector,
951 &SELF_TEST_3DES_2KEY_CBC_test_vector,
952 &SELF_TEST_3DES_3KEY_CBC_test_vector,
953 &SELF_TEST_AES128_CCM_test_vector,
954 &SELF_TEST_SHA1_HMAC_test_vector,
955 &SELF_TEST_SHA224_HMAC_test_vector,
956 &SELF_TEST_SHA256_HMAC_test_vector,
957 &SELF_TEST_SHA384_HMAC_test_vector,
958 &SELF_TEST_SHA512_HMAC_test_vector,
959 &SELF_TEST_AES_CMAC_test_vector,
960 &SELF_TEST_AES128_GCM_encrypt_test_vector,
961 &SELF_TEST_AES192_GCM_encrypt_test_vector,
962 &SELF_TEST_AES256_GCM_encrypt_test_vector,
963 &SELF_TEST_AES128_CTR_test_vector,
964 &SELF_TEST_AES192_CTR_test_vector,
965 &SELF_TEST_AES256_CTR_test_vector,
966 };
967
968 struct fips_dev_auto_test_env {
969 struct rte_mempool *mpool;
970 struct rte_mempool *op_pool;
971 struct rte_mempool *sess_pool;
972 struct rte_mbuf *mbuf;
973 struct rte_crypto_op *op;
974 };
975
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 *,
979 uint32_t, uint8_t *,
980 uint32_t);
981
982 typedef int (*fips_dev_self_test_prepare_op_t)(struct rte_crypto_op *,
983 struct rte_mbuf *, void *,
984 uint32_t, struct fips_dev_self_test_vector *);
985
986 typedef int (*fips_dev_self_test_check_result_t)(struct rte_crypto_op *,
987 struct fips_dev_self_test_vector *, uint32_t);
988
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;
994 };
995
996 static int
prepare_cipher_xform(uint8_t dev_id,struct rte_crypto_sym_xform * xform,struct fips_dev_self_test_vector * vec,uint32_t dir,uint8_t * key,uint32_t neg_test)997 prepare_cipher_xform(uint8_t dev_id,
998 struct rte_crypto_sym_xform *xform,
999 struct fips_dev_self_test_vector *vec,
1000 uint32_t dir,
1001 uint8_t *key,
1002 uint32_t neg_test)
1003 {
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;
1007
1008 memset(xform, 0, sizeof(*xform));
1009
1010 /** negative test, key is xored */
1011 if (neg_test) {
1012 uint32_t i;
1013
1014 for (i = 0; i < vec->key.len; i++)
1015 key[i] ^= vec->key.data[i];
1016 } else
1017 memcpy(key, vec->key.data, vec->key.len);
1018
1019 xform->type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1020
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;
1029
1030 cap_idx.algo.cipher = cipher_xform->algo;
1031 cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
1032
1033 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1034 if (!cap) {
1035 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
1036 dev_id);
1037 return -EACCES;
1038 }
1039
1040 if (rte_cryptodev_sym_capability_check_cipher(cap,
1041 cipher_xform->key.length,
1042 cipher_xform->iv.length) != 0) {
1043 RTE_LOG(ERR, USER1, "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);
1047 return -EACCES;
1048 }
1049
1050 return 0;
1051 }
1052
1053 static int
prepare_auth_xform(uint8_t dev_id,struct rte_crypto_sym_xform * xform,struct fips_dev_self_test_vector * vec,uint32_t dir,uint8_t * key,uint32_t neg_test)1054 prepare_auth_xform(uint8_t dev_id,
1055 struct rte_crypto_sym_xform *xform,
1056 struct fips_dev_self_test_vector *vec,
1057 uint32_t dir,
1058 uint8_t *key,
1059 uint32_t neg_test)
1060 {
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;
1064
1065 memset(xform, 0, sizeof(*xform));
1066
1067 /** negative test, key is xored */
1068 if (neg_test) {
1069 uint32_t i;
1070
1071 for (i = 0; i < vec->key.len; i++)
1072 key[i] ^= vec->key.data[i];
1073 } else
1074 memcpy(key, vec->key.data, vec->key.len);
1075
1076 xform->type = RTE_CRYPTO_SYM_XFORM_AUTH;
1077
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;
1085
1086 cap_idx.algo.auth = auth_xform->algo;
1087 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
1088
1089 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1090 if (!cap) {
1091 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
1092 dev_id);
1093 return -EACCES;
1094 }
1095
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, USER1, "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);
1103 return -EACCES;
1104 }
1105
1106 return 0;
1107 }
1108
1109 static int
prepare_aead_xform(uint8_t dev_id,struct rte_crypto_sym_xform * xform,struct fips_dev_self_test_vector * vec,uint32_t dir,uint8_t * key,uint32_t neg_test)1110 prepare_aead_xform(uint8_t dev_id,
1111 struct rte_crypto_sym_xform *xform,
1112 struct fips_dev_self_test_vector *vec,
1113 uint32_t dir,
1114 uint8_t *key,
1115 uint32_t neg_test)
1116 {
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;
1120
1121 memset(xform, 0, sizeof(*xform));
1122
1123 /** negative test, key is xored */
1124 if (neg_test) {
1125 uint32_t i;
1126
1127 for (i = 0; i < vec->key.len; i++)
1128 key[i] ^= vec->key.data[i];
1129 } else
1130 memcpy(key, vec->key.data, vec->key.len);
1131
1132 xform->type = RTE_CRYPTO_SYM_XFORM_AEAD;
1133
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;
1144
1145 cap_idx.algo.aead = aead_xform->algo;
1146 cap_idx.type = RTE_CRYPTO_SYM_XFORM_AEAD;
1147
1148 cap = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
1149 if (!cap) {
1150 RTE_LOG(ERR, USER1, "Failed to get capability for cdev %u\n",
1151 dev_id);
1152 return -EACCES;
1153 }
1154
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) {
1159 RTE_LOG(ERR, USER1,
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);
1166 return -EACCES;
1167 }
1168
1169 return 0;
1170 }
1171
1172 static int
prepare_cipher_op(struct rte_crypto_op * op,struct rte_mbuf * mbuf,void * session,uint32_t dir,struct fips_dev_self_test_vector * vec)1173 prepare_cipher_op(struct rte_crypto_op *op,
1174 struct rte_mbuf *mbuf,
1175 void *session,
1176 uint32_t dir,
1177 struct fips_dev_self_test_vector *vec)
1178 {
1179 struct rte_crypto_sym_op *sym = op->sym;
1180 uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1181 uint8_t *dst;
1182 const uint8_t *src;
1183 uint32_t len;
1184
1185 if (dir == self_test_dir_enc_auth_gen) {
1186 src = vec->input.data;
1187 len = vec->input.len;
1188 } else {
1189 src = vec->output.data;
1190 len = vec->output.len;
1191 }
1192
1193 sym->cipher.data.offset = 0;
1194 memcpy(iv, vec->iv.data, vec->iv.len);
1195
1196 dst = (uint8_t *)rte_pktmbuf_append(mbuf, len);
1197 if (!dst) {
1198 RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n", -ENOMEM);
1199 return -ENOMEM;
1200 }
1201
1202 memcpy(dst, src, len);
1203
1204 sym->cipher.data.length = len;
1205
1206 rte_crypto_op_attach_sym_session(op, session);
1207
1208 return 0;
1209 }
1210
1211 static int
prepare_auth_op(struct rte_crypto_op * op,struct rte_mbuf * mbuf,void * session,uint32_t dir,struct fips_dev_self_test_vector * vec)1212 prepare_auth_op(struct rte_crypto_op *op,
1213 struct rte_mbuf *mbuf,
1214 void *session,
1215 uint32_t dir,
1216 struct fips_dev_self_test_vector *vec)
1217 {
1218 struct rte_crypto_sym_op *sym = op->sym;
1219 uint8_t *dst;
1220
1221 if (vec->input.len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1222 RTE_LOG(ERR, USER1, "Error %i: Test data too long (%u).\n",
1223 -ENOMEM, vec->input.len + vec->digest.len);
1224 return -ENOMEM;
1225 }
1226
1227 sym->auth.data.offset = 0;
1228
1229 dst = (uint8_t *)rte_pktmbuf_append(mbuf, vec->input.len +
1230 vec->digest.len);
1231 if (!dst) {
1232 RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n", -ENOMEM);
1233 return -ENOMEM;
1234 }
1235
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;
1239 sym->auth.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf,
1240 vec->input.len);
1241
1242 if (dir == self_test_dir_dec_auth_verify)
1243 memcpy(dst + vec->input.len, vec->digest.data, vec->digest.len);
1244
1245 rte_crypto_op_attach_sym_session(op, session);
1246
1247 return 0;
1248 }
1249
1250 static int
prepare_aead_op(struct rte_crypto_op * op,struct rte_mbuf * mbuf,void * session,uint32_t dir,struct fips_dev_self_test_vector * vec)1251 prepare_aead_op(struct rte_crypto_op *op,
1252 struct rte_mbuf *mbuf,
1253 void *session,
1254 uint32_t dir,
1255 struct fips_dev_self_test_vector *vec)
1256 {
1257 struct rte_crypto_sym_op *sym = op->sym;
1258 uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF);
1259 uint8_t *dst;
1260 const uint8_t *src;
1261 uint32_t len;
1262
1263 if (dir == self_test_dir_enc_auth_gen) {
1264 len = vec->input.len;
1265 src = vec->input.data;
1266 } else {
1267 len = vec->output.len;
1268 src = vec->output.data;
1269 }
1270
1271 if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
1272 memcpy(iv + 1, vec->iv.data, vec->iv.len);
1273 else
1274 memcpy(iv, vec->iv.data, vec->iv.len);
1275
1276 if (len + vec->digest.len > RTE_MBUF_MAX_NB_SEGS) {
1277 RTE_LOG(ERR, USER1, "Error %i: Test data too long (%u).\n",
1278 -ENOMEM, len + vec->digest.len);
1279 return -ENOMEM;
1280 }
1281
1282 dst = (uint8_t *)rte_pktmbuf_append(mbuf, RTE_ALIGN_CEIL(len +
1283 vec->digest.len, 16));
1284 if (!dst) {
1285 RTE_LOG(ERR, USER1, "Error %i: MBUF too small\n", -ENOMEM);
1286 return -ENOMEM;
1287 }
1288
1289 sym->m_src = mbuf;
1290 sym->aead.data.length = len;
1291 sym->aead.data.offset = 0;
1292 memcpy(dst, src, len);
1293
1294 sym->aead.digest.data = dst + vec->input.len;
1295 sym->aead.digest.phys_addr = rte_pktmbuf_iova_offset(mbuf,
1296 vec->input.len);
1297 if (dir == self_test_dir_dec_auth_verify)
1298 memcpy(sym->aead.digest.data, vec->digest.data, vec->digest.len);
1299
1300 len = (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM) ?
1301 (vec->aead.aad.len + AES_CCM_AAD_PAD_SIZE) :
1302 vec->aead.aad.len;
1303
1304 dst = rte_malloc(NULL, len, 16);
1305 if (!dst) {
1306 RTE_LOG(ERR, USER1, "Error %i: Not enough memory\n", -ENOMEM);
1307 return -ENOMEM;
1308 }
1309
1310 sym->aead.aad.data = dst;
1311 sym->aead.aad.phys_addr = rte_malloc_virt2iova(dst);
1312 if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM)
1313 memcpy(dst, vec->aead.aad.data,
1314 vec->aead.aad.len + AES_CCM_AAD_PAD_SIZE);
1315 else
1316 memcpy(dst, vec->aead.aad.data,
1317 vec->aead.aad.len);
1318
1319 rte_crypto_op_attach_sym_session(op, session);
1320
1321 return 0;
1322 }
1323
1324 static int
check_cipher_result(struct rte_crypto_op * op,struct fips_dev_self_test_vector * vec,uint32_t dir)1325 check_cipher_result(struct rte_crypto_op *op,
1326 struct fips_dev_self_test_vector *vec,
1327 uint32_t dir)
1328 {
1329 struct rte_mbuf *mbuf = op->sym->m_src;
1330 uint8_t *data;
1331 const uint8_t *src;
1332 uint32_t len, src_len;
1333 int ret;
1334
1335 if (!mbuf)
1336 return -1;
1337
1338 if (dir == self_test_dir_enc_auth_gen) {
1339 src = vec->output.data;
1340 src_len = vec->output.len;
1341 } else {
1342 src = vec->input.data;
1343 src_len = vec->input.len;
1344 }
1345
1346 GET_MBUF_DATA(data, len, mbuf);
1347 if (!len)
1348 return -1;
1349
1350 ret = memcmp(data, src, src_len);
1351 if (ret != 0)
1352 return -1;
1353
1354 return 0;
1355 }
1356
1357 static int
check_auth_result(struct rte_crypto_op * op,struct fips_dev_self_test_vector * vec,uint32_t dir)1358 check_auth_result(struct rte_crypto_op *op,
1359 struct fips_dev_self_test_vector *vec,
1360 uint32_t dir)
1361 {
1362 struct rte_mbuf *mbuf = op->sym->m_src;
1363 uint8_t *data;
1364 uint32_t len;
1365 int ret;
1366
1367 if (mbuf == NULL)
1368 return -1;
1369
1370 GET_MBUF_DATA(data, len, mbuf);
1371 if (!len)
1372 return -1;
1373
1374 if (dir == self_test_dir_enc_auth_gen) {
1375 data += vec->input.len;
1376 ret = memcmp(data, vec->digest.data, vec->digest.len);
1377 if (ret != 0)
1378 return -1;
1379 }
1380
1381 return 0;
1382 }
1383
1384 static int
check_aead_result(struct rte_crypto_op * op,struct fips_dev_self_test_vector * vec,uint32_t dir)1385 check_aead_result(struct rte_crypto_op *op,
1386 struct fips_dev_self_test_vector *vec,
1387 uint32_t dir)
1388 {
1389 struct rte_mbuf *mbuf = op->sym->m_src;
1390 uint8_t *data;
1391 const uint8_t *src;
1392 uint32_t len, src_len;
1393 int ret;
1394
1395 if (!mbuf)
1396 return -1;
1397
1398 rte_free(op->sym->aead.aad.data);
1399
1400 if (dir == self_test_dir_enc_auth_gen) {
1401 src = vec->output.data;
1402 src_len = vec->output.len;
1403 } else {
1404 src = vec->input.data;
1405 src_len = vec->input.len;
1406 }
1407
1408 GET_MBUF_DATA(data, len, mbuf);
1409 if (!len)
1410 return -1;
1411
1412 ret = memcmp(data, src, src_len);
1413 if (ret != 0)
1414 return -1;
1415
1416 if (dir == self_test_dir_enc_auth_gen) {
1417 data += src_len;
1418 ret = memcmp(data, vec->digest.data, vec->digest.len);
1419 if (ret != 0)
1420 return -1;
1421 }
1422
1423 return 0;
1424 }
1425
1426 static void
init_test_op(struct fips_dev_self_test_ops * test_ops,struct fips_dev_self_test_vector * vec)1427 init_test_op(struct fips_dev_self_test_ops *test_ops,
1428 struct fips_dev_self_test_vector *vec)
1429 {
1430 if (test_ops->last_operation_type == vec->operation_type)
1431 return;
1432
1433 switch (vec->operation_type) {
1434 case RTE_CRYPTO_SYM_XFORM_CIPHER:
1435 test_ops->prepare_xform = prepare_cipher_xform;
1436 test_ops->prepare_op = prepare_cipher_op;
1437 test_ops->check_result = check_cipher_result;
1438 break;
1439 case RTE_CRYPTO_SYM_XFORM_AUTH:
1440 test_ops->prepare_xform = prepare_auth_xform;
1441 test_ops->prepare_op = prepare_auth_op;
1442 test_ops->check_result = check_auth_result;
1443 break;
1444 case RTE_CRYPTO_SYM_XFORM_AEAD:
1445 test_ops->prepare_xform = prepare_aead_xform;
1446 test_ops->prepare_op = prepare_aead_op;
1447 test_ops->check_result = check_aead_result;
1448 break;
1449 default:
1450 break;
1451 }
1452
1453 test_ops->last_operation_type = vec->operation_type;
1454 }
1455
1456 static int
run_single_test(uint8_t dev_id,struct fips_dev_self_test_vector * vec,const struct fips_dev_self_test_ops * test_ops,struct fips_dev_auto_test_env * env,uint32_t dir,uint32_t negative_test)1457 run_single_test(uint8_t dev_id,
1458 struct fips_dev_self_test_vector *vec,
1459 const struct fips_dev_self_test_ops *test_ops,
1460 struct fips_dev_auto_test_env *env,
1461 uint32_t dir,
1462 uint32_t negative_test)
1463 {
1464 struct rte_crypto_sym_xform xform;
1465 void *sess;
1466 uint16_t n_deqd;
1467 uint8_t key[256];
1468 int ret;
1469
1470 __rte_crypto_op_reset(env->op, RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1471 rte_pktmbuf_reset(env->mbuf);
1472 env->op->sym->m_src = env->mbuf;
1473
1474 ret = test_ops->prepare_xform(dev_id, &xform, vec, dir, key,
1475 negative_test);
1476 if (ret < 0) {
1477 RTE_LOG(ERR, USER1, "Error %i: Prepare Xform\n", ret);
1478 return ret;
1479 }
1480
1481 sess = rte_cryptodev_sym_session_create(dev_id, &xform, env->sess_pool);
1482 if (!sess) {
1483 RTE_LOG(ERR, USER1, "Error %i: Init session\n", ret);
1484 return ret;
1485 }
1486
1487 ret = test_ops->prepare_op(env->op, env->mbuf, sess, dir, vec);
1488 if (ret < 0) {
1489 RTE_LOG(ERR, USER1, "Error %i: Prepare op\n", ret);
1490 return ret;
1491 }
1492
1493 if (rte_cryptodev_enqueue_burst(dev_id, 0, &env->op, 1) < 1) {
1494 RTE_LOG(ERR, USER1, "Error: Failed enqueue\n");
1495 return ret;
1496 }
1497
1498 do {
1499 struct rte_crypto_op *deqd_op;
1500
1501 n_deqd = rte_cryptodev_dequeue_burst(dev_id, 0, &deqd_op,
1502 1);
1503 } while (n_deqd == 0);
1504
1505 rte_cryptodev_sym_session_free(dev_id, sess);
1506
1507 if (env->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS)
1508 return -1;
1509
1510 return test_ops->check_result(env->op, vec, dir);
1511 }
1512
1513
1514 static void
fips_dev_auto_test_uninit(uint8_t dev_id,struct fips_dev_auto_test_env * env)1515 fips_dev_auto_test_uninit(uint8_t dev_id,
1516 struct fips_dev_auto_test_env *env)
1517 {
1518 rte_pktmbuf_free(env->mbuf);
1519 rte_crypto_op_free(env->op);
1520 rte_mempool_free(env->mpool);
1521 rte_mempool_free(env->op_pool);
1522 rte_mempool_free(env->sess_pool);
1523
1524 rte_cryptodev_stop(dev_id);
1525 }
1526
1527 static int
fips_dev_auto_test_init(uint8_t dev_id,struct fips_dev_auto_test_env * env)1528 fips_dev_auto_test_init(uint8_t dev_id, struct fips_dev_auto_test_env *env)
1529 {
1530 struct rte_cryptodev_qp_conf qp_conf = {128, NULL};
1531 uint32_t sess_sz = rte_cryptodev_sym_get_private_session_size(dev_id);
1532 struct rte_cryptodev_config conf;
1533 char name[128];
1534 int ret;
1535
1536 conf.socket_id = rte_cryptodev_socket_id(dev_id);
1537 conf.nb_queue_pairs = 1;
1538 conf.ff_disable = 0;
1539
1540 ret = rte_cryptodev_configure(dev_id, &conf);
1541 if (ret < 0)
1542 return ret;
1543
1544 memset(name, 0, 128);
1545 snprintf(name, 128, "%s%u", "SELF_TEST_MEMPOOL", dev_id);
1546
1547 memset(env, 0, sizeof(*env));
1548
1549 env->mpool = rte_pktmbuf_pool_create(name, 128, 0, 0,
1550 UINT16_MAX, rte_cryptodev_socket_id(dev_id));
1551 if (!env->mpool) {
1552 ret = -ENOMEM;
1553 goto error_exit;
1554 }
1555
1556 memset(name, 0, 128);
1557 snprintf(name, 128, "%s%u", "SELF_TEST_OP_POOL", dev_id);
1558
1559 env->op_pool = rte_crypto_op_pool_create(
1560 name,
1561 RTE_CRYPTO_OP_TYPE_SYMMETRIC,
1562 16, 0,
1563 16,
1564 rte_socket_id());
1565 if (!env->op_pool) {
1566 ret = -ENOMEM;
1567 goto error_exit;
1568 }
1569
1570 memset(name, 0, 128);
1571 snprintf(name, 128, "%s%u", "SELF_TEST_SESS_POOL", dev_id);
1572
1573 env->sess_pool = rte_cryptodev_sym_session_pool_create(name,
1574 128, sess_sz, 0, 0, rte_cryptodev_socket_id(dev_id));
1575 if (!env->sess_pool) {
1576 ret = -ENOMEM;
1577 goto error_exit;
1578 }
1579
1580 qp_conf.mp_session = env->sess_pool;
1581
1582 ret = rte_cryptodev_queue_pair_setup(dev_id, 0, &qp_conf,
1583 rte_cryptodev_socket_id(dev_id));
1584 if (ret < 0)
1585 goto error_exit;
1586
1587 env->mbuf = rte_pktmbuf_alloc(env->mpool);
1588 if (!env->mbuf) {
1589 ret = -ENOMEM;
1590 goto error_exit;
1591 }
1592
1593 env->op = rte_crypto_op_alloc(env->op_pool,
1594 RTE_CRYPTO_OP_TYPE_SYMMETRIC);
1595 if (!env->op) {
1596 ret = -ENOMEM;
1597 goto error_exit;
1598 }
1599
1600 ret = rte_cryptodev_start(dev_id);
1601 if (ret < 0)
1602 goto error_exit;
1603
1604
1605 return 0;
1606
1607 error_exit:
1608
1609 fips_dev_auto_test_uninit(dev_id, env);
1610
1611 return ret;
1612 }
1613
1614 int
fips_dev_self_test(uint8_t dev_id,struct fips_dev_broken_test_config * config)1615 fips_dev_self_test(uint8_t dev_id,
1616 struct fips_dev_broken_test_config *config)
1617 {
1618 struct fips_dev_self_test_ops test_ops = {0};
1619 struct fips_dev_auto_test_env env;
1620 uint32_t i, j, negative_test;
1621 int ret;
1622
1623 ret = fips_dev_auto_test_init(dev_id, &env);
1624 if (ret < 0) {
1625 RTE_LOG(ERR, USER1, "Failed to init self-test for PMD %u\n",
1626 dev_id);
1627 return ret;
1628 }
1629
1630 for (i = 0; i < RTE_DIM(self_test_vectors); i++) {
1631 struct fips_dev_self_test_vector *vec =
1632 self_test_vectors[i];
1633
1634 init_test_op(&test_ops, vec);
1635
1636 for (j = 0; j < self_test_dir_max; j++) {
1637 if (!config)
1638 negative_test = 0;
1639 else {
1640 if ((config->expect_fail_test_idx == i) &&
1641 (config->expect_fail_dir == j))
1642 negative_test = 1;
1643 else
1644 negative_test = 0;
1645 }
1646
1647 RTE_LOG(INFO, USER1, "Testing (ID %u) %s %s%s...\n",
1648 i,
1649 vec->name,
1650 j == self_test_dir_enc_auth_gen ?
1651 "Encrypt" : "Decrypt",
1652 negative_test ? " (Expect Fail)" : "");
1653
1654 ret = run_single_test(dev_id, vec, &test_ops,
1655 &env, j, negative_test);
1656 switch (ret) {
1657 case 0:
1658 if (!negative_test)
1659 break;
1660 ret = -1;
1661 RTE_LOG(ERR, USER1, "PMD %u Failed test %s %s\n",
1662 dev_id, vec->name,
1663 j == self_test_dir_enc_auth_gen ?
1664 "Encrypt" : "Decrypt");
1665 goto error_exit;
1666 case -EACCES:
1667 RTE_LOG(ERR, USER1, "Not supported by %s. Skip\n",
1668 rte_cryptodev_name_get(dev_id));
1669 ret = 0;
1670 break;
1671 default:
1672 RTE_LOG(ERR, USER1, "PMD %u Failed test %s %s\n",
1673 dev_id, vec->name,
1674 j == self_test_dir_enc_auth_gen ?
1675 "Encrypt" : "Decrypt");
1676 goto error_exit;
1677 }
1678 }
1679 }
1680
1681 error_exit:
1682 fips_dev_auto_test_uninit(dev_id, &env);
1683
1684 if (ret == 0) {
1685 RTE_LOG(INFO, USER1, "PMD %u finished self-test successfully\n",
1686 dev_id);
1687 }
1688
1689 return ret;
1690 }
1691