1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Intel Corporation
9 #include <rte_cryptodev.h>
10 #include <rte_malloc.h>
12 #include "fips_validation.h"
14 #define MODE_STR "AESVS"
15 #define ALGO_STR "test data for "
16 #define OP_STR "State"
17 #define KEY_SIZE_STR "Key Length : "
20 #define COUNT_STR "COUNT = "
21 #define KEY_STR "KEY = "
22 #define IV_STR "IV = "
23 #define PT_STR "PLAINTEXT = "
24 #define CT_STR "CIPHERTEXT = "
26 #define OP_ENC_STR "ENCRYPT"
27 #define OP_DEC_STR "DECRYPT"
29 #define ALGO_JSON_STR "algorithm"
30 #define TESTTYPE_JSON_STR "testType"
31 #define DIR_JSON_STR "direction"
32 #define KEYLEN_JSON_STR "keyLen"
34 #define KEY_JSON_STR "key"
35 #define IV_JSON_STR "iv"
36 #define PT_JSON_STR "pt"
37 #define CT_JSON_STR "ct"
39 #define OP_ENC_JSON_STR "encrypt"
40 #define OP_DEC_JSON_STR "decrypt"
45 } aes_test_types[] = {
46 {AESAVS_TYPE_GFXBOX, "GFSbox"},
47 {AESAVS_TYPE_KEYSBOX, "KeySbox"},
48 {AESAVS_TYPE_VARKEY, "VarKey"},
49 {AESAVS_TYPE_VARTXT, "VarTxt"},
50 {TDES_VARIABLE_TEXT, "VARIABLE PLAINTEXT/CIPHERTEXT"},
51 {TDES_VARIABLE_TEXT, "KAT"},
52 {AESAVS_TYPE_MMT, "MMT"},
53 {AESAVS_TYPE_MCT, "MCT"},
54 {AESAVS_TYPE_AFT, "AFT"},
57 struct aes_test_algo {
59 enum rte_crypto_cipher_algorithm algo;
60 } const algo_con[] = {
61 {"CBC", RTE_CRYPTO_CIPHER_AES_CBC},
62 {"ECB", RTE_CRYPTO_CIPHER_AES_ECB},
66 parse_interim_enc_dec(const char *key,
67 __rte_unused char *text,
68 __rte_unused struct fips_val *val)
70 if (strcmp(key, OP_ENC_STR) == 0)
71 info.op = FIPS_TEST_ENC_AUTH_GEN;
72 else if (strcmp(key, OP_DEC_STR) == 0)
73 info.op = FIPS_TEST_DEC_AUTH_VERIF;
80 struct fips_test_callback aes_tests_interim[] = {
81 {OP_ENC_STR, parse_interim_enc_dec, NULL},
82 {OP_DEC_STR, parse_interim_enc_dec, NULL},
83 {NULL, NULL, NULL} /**< end pointer */
86 struct fips_test_callback aes_tests_vectors[] = {
87 {KEY_STR, parse_uint8_hex_str, &vec.cipher_auth.key},
88 {IV_STR, parse_uint8_hex_str, &vec.iv},
89 {PT_STR, parse_uint8_hex_str, &vec.pt},
90 {CT_STR, parse_uint8_hex_str, &vec.ct},
91 {NULL, NULL, NULL} /**< end pointer */
94 struct fips_test_callback aes_tests_interim_vectors[] = {
95 {OP_ENC_STR, parse_interim_enc_dec, NULL},
96 {OP_DEC_STR, parse_interim_enc_dec, NULL},
97 {NULL, NULL, NULL} /**< end pointer */
100 struct fips_test_callback aes_writeback_callbacks[] = {
101 /** First element is used to pass COUNT string */
102 {COUNT_STR, NULL, NULL},
103 {IV_STR, writeback_hex_str, &vec.iv},
104 {KEY_STR, writeback_hex_str, &vec.cipher_auth.key},
105 {PT_STR, writeback_hex_str, &vec.pt},
106 {CT_STR, writeback_hex_str, &vec.ct},
107 {NULL, NULL, NULL} /**< end pointer */
110 #ifdef RTE_HAS_JANSSON
111 struct fips_test_callback aes_dec_json_vectors[] = {
112 {KEY_JSON_STR, parse_uint8_known_len_hex_str, &vec.cipher_auth.key},
113 {IV_JSON_STR, parse_uint8_hex_str, &vec.iv},
114 {CT_JSON_STR, parse_uint8_hex_str, &vec.ct},
115 {NULL, NULL, NULL} /**< end pointer */
118 struct fips_test_callback aes_interim_json_vectors[] = {
119 {KEYLEN_JSON_STR, parser_read_uint32_bit_val, &vec.cipher_auth.key},
120 {NULL, NULL, NULL} /**< end pointer */
123 struct fips_test_callback aes_enc_json_vectors[] = {
124 {KEY_JSON_STR, parse_uint8_known_len_hex_str, &vec.cipher_auth.key},
125 {IV_JSON_STR, parse_uint8_hex_str, &vec.iv},
126 {PT_JSON_STR, parse_uint8_hex_str, &vec.pt},
127 {NULL, NULL, NULL} /**< end pointer */
131 parse_test_aes_json_writeback(struct fips_val *val)
133 struct fips_val tmp_val;
136 tcId = json_object_get(json_info.json_test_case, "tcId");
138 json_info.json_write_case = json_object();
139 json_object_set(json_info.json_write_case, "tcId", tcId);
141 if (info.op == FIPS_TEST_ENC_AUTH_GEN) {
144 tmp_val.val = val->val;
145 tmp_val.len = vec.pt.len;
147 writeback_hex_str("", info.one_line_text, &tmp_val);
148 ct = json_string(info.one_line_text);
149 json_object_set_new(json_info.json_write_case, CT_JSON_STR, ct);
151 tmp_val.val = val->val + vec.pt.len;
152 tmp_val.len = val->len - vec.pt.len;
154 writeback_hex_str("", info.one_line_text, &tmp_val);
156 if (vec.status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
157 tmp_val.val = val->val;
158 tmp_val.len = vec.ct.len;
160 writeback_hex_str("", info.one_line_text, &tmp_val);
161 json_object_set_new(json_info.json_write_case, PT_JSON_STR,
162 json_string(info.one_line_text));
164 json_object_set_new(json_info.json_write_case, "testPassed", json_false());
172 parse_test_aes_mct_json_writeback(struct fips_val *val)
174 json_t *tcId, *resArr, *res, *ct, *pt, *key, *iv;
175 struct fips_val tmp_val;
177 tcId = json_object_get(json_info.json_test_case, "tcId");
178 if (json_info.json_write_case) {
181 wcId = json_object_get(json_info.json_write_case, "tcId");
182 if (!json_equal(tcId, wcId)) {
183 json_info.json_write_case = json_object();
184 json_object_set(json_info.json_write_case, "tcId", tcId);
185 json_object_set(json_info.json_write_case, "resultsArray", json_array());
188 json_info.json_write_case = json_object();
189 json_object_set(json_info.json_write_case, "tcId", tcId);
190 json_object_set(json_info.json_write_case, "resultsArray", json_array());
193 resArr = json_object_get(json_info.json_write_case, "resultsArray");
194 if (!json_is_array(resArr))
198 if (info .op == FIPS_TEST_ENC_AUTH_GEN) {
199 writeback_hex_str("", info.one_line_text, &vec.cipher_auth.key);
200 key = json_string(info.one_line_text);
201 json_object_set_new(res, KEY_JSON_STR, key);
203 writeback_hex_str("", info.one_line_text, &val[2]);
204 iv = json_string(info.one_line_text);
205 json_object_set_new(res, IV_JSON_STR, iv);
207 writeback_hex_str("", info.one_line_text, &val[1]);
208 pt = json_string(info.one_line_text);
209 json_object_set_new(res, PT_JSON_STR, pt);
211 tmp_val.val = val->val;
212 tmp_val.len = vec.pt.len;
214 writeback_hex_str("", info.one_line_text, &tmp_val);
215 ct = json_string(info.one_line_text);
216 json_object_set_new(res, CT_JSON_STR, ct);
218 tmp_val.val = val->val + vec.pt.len;
219 tmp_val.len = val->len - vec.pt.len;
221 writeback_hex_str("", info.one_line_text, &tmp_val);
223 if (vec.status == RTE_CRYPTO_OP_STATUS_SUCCESS) {
224 writeback_hex_str("", info.one_line_text, &vec.cipher_auth.key);
225 key = json_string(info.one_line_text);
226 json_object_set_new(res, KEY_JSON_STR, key);
228 writeback_hex_str("", info.one_line_text, &val[2]);
229 iv = json_string(info.one_line_text);
230 json_object_set_new(res, IV_JSON_STR, iv);
232 tmp_val.val = val->val;
233 tmp_val.len = vec.ct.len;
235 writeback_hex_str("", info.one_line_text, &tmp_val);
236 pt = json_string(info.one_line_text);
237 json_object_set_new(res, PT_JSON_STR, pt);
239 writeback_hex_str("", info.one_line_text, &val[1]);
240 ct = json_string(info.one_line_text);
241 json_object_set_new(res, CT_JSON_STR, ct);
243 json_object_set_new(json_info.json_write_case, "testPassed", json_false());
247 json_array_append_new(resArr, res);
252 parse_test_aes_json_init(void)
254 json_t *type_obj = json_object_get(json_info.json_test_group, TESTTYPE_JSON_STR);
255 json_t *algo_obj = json_object_get(json_info.json_vector_set, ALGO_JSON_STR);
256 const char *type_str = json_string_value(type_obj);
257 const char *algo_str = json_string_value(algo_obj);
260 if (json_info.json_test_group) {
261 json_t *direction_obj;
262 const char *direction_str;
264 direction_obj = json_object_get(json_info.json_test_group, DIR_JSON_STR);
265 direction_str = json_string_value(direction_obj);
267 if (strcmp(direction_str, OP_ENC_JSON_STR) == 0) {
268 info.op = FIPS_TEST_ENC_AUTH_GEN;
269 info.callbacks = aes_enc_json_vectors;
271 } else if (strcmp(direction_str, OP_DEC_JSON_STR) == 0) {
272 info.op = FIPS_TEST_DEC_AUTH_VERIF;
273 info.callbacks = aes_dec_json_vectors;
277 info.interim_callbacks = aes_interim_json_vectors;
280 for (i = 0; i < RTE_DIM(aes_test_types); i++)
281 if (strstr(type_str, aes_test_types[i].desc)) {
282 info.interim_info.aes_data.test_type =
283 aes_test_types[i].type;
287 if (i >= RTE_DIM(aes_test_types))
290 switch (info.interim_info.aes_data.test_type) {
291 case AESAVS_TYPE_MCT:
292 info.parse_writeback = parse_test_aes_mct_json_writeback;
294 case AESAVS_TYPE_AFT:
295 info.parse_writeback = parse_test_aes_json_writeback;
298 info.parse_writeback = NULL;
301 if (!info.parse_writeback)
304 for (i = 0; i < RTE_DIM(algo_con); i++)
305 if (strstr(algo_str, algo_con[i].name)) {
306 info.interim_info.aes_data.cipher_algo =
307 (uint32_t)algo_con[i].algo;
311 if (i >= RTE_DIM(algo_con))
316 #endif /* RTE_HAS_JANSSON */
319 parse_test_aes_writeback(struct fips_val *val)
321 if (info.op == FIPS_TEST_ENC_AUTH_GEN)
322 fprintf(info.fp_wr, "%s", CT_STR);
324 fprintf(info.fp_wr, "%s", PT_STR);
326 parse_write_hex_str(val);
332 rsp_test_aes_check(struct fips_val *val)
334 struct fips_val *data;
336 if (info.op == FIPS_TEST_ENC_AUTH_GEN)
341 if (memcmp(val->val, data->val, val->len) == 0)
342 fprintf(info.fp_wr, "Success\n");
344 fprintf(info.fp_wr, "Failed\n");
350 parse_test_aes_init(void)
355 for (i = 0; i < info.nb_vec_lines; i++) {
356 char *line = info.vec[i];
358 tmp = strstr(line, MODE_STR);
360 for (j = 0; j < RTE_DIM(aes_test_types); j++)
361 if (strstr(line, aes_test_types[j].desc)) {
362 info.interim_info.aes_data.test_type =
363 aes_test_types[j].type;
367 if (j >= RTE_DIM(aes_test_types))
370 tmp = strstr(line, ALGO_STR);
374 tmp += strlen(ALGO_STR);
375 for (j = 0; j < RTE_DIM(algo_con); j++)
376 if (strcmp(algo_con[j].name, tmp) == 0) {
377 info.interim_info.aes_data.cipher_algo =
378 (uint32_t)algo_con[j].algo;
381 if (j >= RTE_DIM(algo_con))
387 tmp = strstr(line, OP_STR);
391 tmp = strstr(line, KEY_SIZE_STR);
393 tmp += strlen(KEY_SIZE_STR);
394 if (parser_read_uint32
395 (&info.interim_info.aes_data.key_len,
399 info.interim_info.aes_data.key_len /= 8;
405 info.parse_writeback = parse_test_aes_writeback;
406 info.callbacks = aes_tests_vectors;
407 info.interim_callbacks = aes_tests_interim_vectors;
408 info.writeback_callbacks = aes_writeback_callbacks;
409 info.kat_check = rsp_test_aes_check;