1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 Intel Corporation 3 */ 4 5 #include <stdio.h> 6 #include <string.h> 7 8 #include <rte_string_fns.h> 9 #include <rte_cryptodev.h> 10 #include <rte_malloc.h> 11 12 #include "fips_validation.h" 13 14 #define DVPT_STR "CCM-DVPT" 15 #define VADT_STR "CCM-VADT" 16 #define VPT_STR "CCM-VPT" 17 #define VNT_STR "CCM-VNT" 18 #define VTT_STR "CCM-VTT" 19 20 #define PARAM_PREFIX "[" 21 #define ALEN_PREFIX "Alen = " 22 #define PLEN_PREFIX "Plen = " 23 #define IVLEN_PREFIX "Nlen = " 24 #define DIGESTL_PREFIX "Tlen = " 25 26 #define COUNT_STR "Count = " 27 #define KEY_STR "Key = " 28 #define IV_STR "Nonce = " 29 #define PT_STR "Payload = " 30 #define CT_STR "CT = " 31 #define AAD_STR "Adata = " 32 #define POS_NEG_STR "Result = " 33 34 #define POS_KEYWORD "Pass" 35 #define NEG_KEYWORD "Fail" 36 37 static int 38 parser_dvpt_interim(const char *key, char *src, struct fips_val *val) 39 { 40 char *tmp, c, value[10]; 41 char num_pattern[] = "0123456789"; 42 int i = 0; 43 44 memset(value, 0, 10); 45 46 tmp = strstr(src, key); 47 if (!tmp) 48 return -1; 49 50 tmp += strlen(key); 51 52 c = tmp[0]; 53 54 while (strchr(num_pattern, c) && i < 10) { 55 value[i++] = c; 56 c = tmp[i]; 57 } 58 59 return parser_read_uint32_val("", value, val); 60 } 61 62 static int 63 parse_dvpt_ct_hex_str(const char *key, char *src, struct fips_val *val) 64 { 65 int ret; 66 67 val->len = vec.pt.len; 68 69 ret = parse_uint8_known_len_hex_str(key, src, val); 70 if (ret < 0) 71 return ret; 72 73 src += strlen(key) + val->len * 2; 74 75 ret = parse_uint8_known_len_hex_str("", src, &vec.aead.digest); 76 if (ret < 0) { 77 rte_free(val->val); 78 memset(val, 0, sizeof(*val)); 79 return ret; 80 } 81 82 return 0; 83 } 84 85 static int 86 parse_uint8_ccm_aad_str(const char *key, char *src, struct fips_val *val) 87 { 88 uint32_t len = val->len, j; 89 90 src += strlen(key); 91 92 /* CCM aad requires 18 bytes padding before the real content */ 93 val->val = rte_zmalloc(NULL, len + 18, 0); 94 if (!val->val) 95 return -1; 96 97 for (j = 0; j < len; j++) { 98 char byte[3] = {src[j * 2], src[j * 2 + 1], '\0'}; 99 100 if (parser_read_uint8_hex(&val->val[j + 18], byte) < 0) { 101 rte_free(val->val); 102 memset(val, 0, sizeof(*val)); 103 return -EINVAL; 104 } 105 } 106 107 return 0; 108 } 109 110 struct fips_test_callback ccm_vnt_vec[] = { 111 {IV_STR, parse_uint8_known_len_hex_str, &vec.iv}, 112 {AAD_STR, parse_uint8_ccm_aad_str, &vec.aead.aad}, 113 {PT_STR, parse_uint8_known_len_hex_str, &vec.pt}, 114 {NULL, NULL, NULL} /**< end pointer */ 115 }; 116 117 struct fips_test_callback ccm_vnt_interim_vec[] = { 118 {ALEN_PREFIX, parser_read_uint32_val, &vec.aead.aad}, 119 {PLEN_PREFIX, parser_read_uint32_val, &vec.pt}, 120 {DIGESTL_PREFIX, parser_read_uint32_val, &vec.aead.digest}, 121 {IVLEN_PREFIX, parser_read_uint32_val, &vec.iv}, 122 {KEY_STR, parse_uint8_hex_str, &vec.aead.key}, 123 {NULL, NULL, NULL} /**< end pointer */ 124 }; 125 126 struct fips_test_callback ccm_vtt_vec[] = { 127 {AAD_STR, parse_uint8_ccm_aad_str, &vec.aead.aad}, 128 {PT_STR, parse_uint8_known_len_hex_str, &vec.pt}, 129 {NULL, NULL, NULL} /**< end pointer */ 130 }; 131 132 struct fips_test_callback ccm_vtt_interim_vec[] = { 133 {ALEN_PREFIX, parser_read_uint32_val, &vec.aead.aad}, 134 {PLEN_PREFIX, parser_read_uint32_val, &vec.pt}, 135 {IVLEN_PREFIX, parser_read_uint32_val, &vec.iv}, 136 {DIGESTL_PREFIX, parser_read_uint32_val, &vec.aead.digest}, 137 {KEY_STR, parse_uint8_hex_str, &vec.aead.key}, 138 {IV_STR, parse_uint8_known_len_hex_str, &vec.iv}, 139 {NULL, NULL, NULL} /**< end pointer */ 140 }; 141 142 struct fips_test_callback ccm_vadt_vec[] = { 143 {AAD_STR, parse_uint8_ccm_aad_str, &vec.aead.aad}, 144 {PT_STR, parse_uint8_known_len_hex_str, &vec.pt}, 145 {NULL, NULL, NULL} /**< end pointer */ 146 }; 147 148 struct fips_test_callback ccm_vadt_interim_vec[] = { 149 {PLEN_PREFIX, parser_read_uint32_val, &vec.pt}, 150 {IVLEN_PREFIX, parser_read_uint32_val, &vec.iv}, 151 {ALEN_PREFIX, parser_read_uint32_val, &vec.aead.aad}, 152 {DIGESTL_PREFIX, parser_read_uint32_val, &vec.aead.digest}, 153 {KEY_STR, parse_uint8_hex_str, &vec.aead.key}, 154 {IV_STR, parse_uint8_known_len_hex_str, &vec.iv}, 155 {NULL, NULL, NULL} /**< end pointer */ 156 }; 157 158 struct fips_test_callback ccm_vpt_vec[] = { 159 {AAD_STR, parse_uint8_ccm_aad_str, &vec.aead.aad}, 160 {PT_STR, parse_uint8_known_len_hex_str, &vec.pt}, 161 {NULL, NULL, NULL} /**< end pointer */ 162 }; 163 164 struct fips_test_callback ccm_vpt_interim_vec[] = { 165 {ALEN_PREFIX, parser_read_uint32_val, &vec.aead.aad}, 166 {IVLEN_PREFIX, parser_read_uint32_val, &vec.iv}, 167 {DIGESTL_PREFIX, parser_read_uint32_val, &vec.aead.digest}, 168 {PLEN_PREFIX, parser_read_uint32_val, &vec.pt}, 169 {KEY_STR, parse_uint8_hex_str, &vec.aead.key}, 170 {IV_STR, parse_uint8_known_len_hex_str, &vec.iv}, 171 {NULL, NULL, NULL} /**< end pointer */ 172 }; 173 174 struct fips_test_callback ccm_dvpt_vec[] = { 175 {IV_STR, parse_uint8_known_len_hex_str, &vec.iv}, 176 {AAD_STR, parse_uint8_ccm_aad_str, &vec.aead.aad}, 177 {CT_STR, parse_dvpt_ct_hex_str, &vec.ct}, 178 {NULL, NULL, NULL} /**< end pointer */ 179 }; 180 181 struct fips_test_callback ccm_dvpt_interim_vec[] = { 182 {ALEN_PREFIX, parser_dvpt_interim, &vec.aead.aad}, 183 {PLEN_PREFIX, parser_dvpt_interim, &vec.pt}, 184 {IVLEN_PREFIX, parser_dvpt_interim, &vec.iv}, 185 {DIGESTL_PREFIX, parser_dvpt_interim, &vec.aead.digest}, 186 {KEY_STR, parse_uint8_hex_str, &vec.aead.key}, 187 {NULL, NULL, NULL} /**< end pointer */ 188 }; 189 190 struct ccm_test_types { 191 const char *str; 192 uint32_t type; 193 const struct fips_test_callback *cb; 194 const struct fips_test_callback *cb_interim; 195 enum fips_test_op op; 196 } ctt[] = { 197 {DVPT_STR, CCM_DVPT, ccm_dvpt_vec, ccm_dvpt_interim_vec, 198 FIPS_TEST_DEC_AUTH_VERIF}, 199 {VPT_STR, CCM_VPT, ccm_vpt_vec, ccm_vpt_interim_vec, 200 FIPS_TEST_ENC_AUTH_GEN}, 201 {VADT_STR, CCM_VADT, ccm_vadt_vec, ccm_vadt_interim_vec, 202 FIPS_TEST_ENC_AUTH_GEN}, 203 {VNT_STR, CCM_VNT, ccm_vnt_vec, ccm_vnt_interim_vec, 204 FIPS_TEST_ENC_AUTH_GEN}, 205 {VTT_STR, CCM_VTT, ccm_vtt_vec, ccm_vtt_interim_vec, 206 FIPS_TEST_ENC_AUTH_GEN}, 207 }; 208 209 static int 210 parse_test_ccm_writeback(struct fips_val *val) 211 { 212 struct fips_val tmp_val; 213 214 switch (info.interim_info.ccm_data.test_type) { 215 case CCM_DVPT: 216 fprintf(info.fp_wr, "%s", POS_NEG_STR); 217 if (vec.status == RTE_CRYPTO_OP_STATUS_SUCCESS) { 218 fprintf(info.fp_wr, "%s\n", POS_KEYWORD); 219 fprintf(info.fp_wr, "%s", PT_STR); 220 221 tmp_val.val = val->val; 222 tmp_val.len = vec.pt.len; 223 224 if (tmp_val.len == 0) 225 fprintf(info.fp_wr, "00\n"); 226 else 227 parse_write_hex_str(&tmp_val); 228 } else 229 fprintf(info.fp_wr, "%s\n", NEG_KEYWORD); 230 231 break; 232 233 case CCM_VADT: 234 case CCM_VNT: 235 case CCM_VPT: 236 case CCM_VTT: 237 fprintf(info.fp_wr, "%s", CT_STR); 238 239 parse_write_hex_str(val); 240 241 break; 242 243 } 244 245 return 0; 246 } 247 248 int 249 parse_test_ccm_init(void) 250 { 251 252 uint32_t i; 253 254 for (i = 0; i < info.nb_vec_lines; i++) { 255 char *line = info.vec[i]; 256 uint32_t j; 257 258 for (j = 0; j < RTE_DIM(ctt); j++) 259 if (strstr(line, ctt[j].str)) { 260 info.interim_info.ccm_data.test_type = 261 ctt[j].type; 262 info.callbacks = ctt[j].cb; 263 info.interim_callbacks = ctt[j].cb_interim; 264 info.op = ctt[j].op; 265 break; 266 } 267 } 268 269 info.parse_writeback = parse_test_ccm_writeback; 270 271 return 0; 272 } 273