1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2019 Intel Corporation 3 */ 4 5 #include <rte_cryptodev.h> 6 #include <rte_cryptodev_pmd.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 14 struct fips_dev_self_test_vector { 15 const char *name; 16 enum rte_crypto_sym_xform_type operation_type; 17 18 struct { 19 uint8_t data[64]; 20 uint16_t len; 21 } digest; 22 23 struct { 24 uint8_t data[256]; 25 uint16_t len; 26 } key; 27 28 struct { 29 uint8_t data[16]; 30 uint8_t len; 31 } iv; 32 33 union { 34 struct { 35 enum rte_crypto_cipher_algorithm algo; 36 } cipher; 37 38 struct { 39 enum rte_crypto_aead_algorithm algo; 40 struct { 41 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE]; 42 uint16_t len; 43 } aad; 44 } aead; 45 46 struct { 47 enum rte_crypto_auth_algorithm algo; 48 } auth; 49 }; 50 51 struct { 52 const uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE]; 53 uint16_t len; 54 } input; 55 56 struct { 57 uint8_t data[FIPS_DEV_TEST_DATA_MAX_SIZE]; 58 uint16_t len; 59 } output; 60 }; 61 62 #define GET_MBUF_DATA(data, len, m) \ 63 do { \ 64 len = rte_pktmbuf_pkt_len(m); \ 65 data = rte_pktmbuf_mtod(m, uint8_t *); \ 66 } while (0) 67 68 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, 74 75 .auth = { 76 .algo = RTE_CRYPTO_AUTH_SHA1_HMAC, 77 }, 78 .input = { 79 .data = { 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 96 }, 97 .len = 128, 98 }, 99 .key = { 100 .data = { 101 0x8d, 0x8d, 0x15, 0xd8, 0xa9, 0x57, 0x9a, 0xdb, 102 0x2d, 0x62 103 }, 104 .len = 10, 105 }, 106 .digest = { 107 .data = { 108 0x0c, 0x66, 0x2e, 0x47, 0x93, 0x93, 0x8c, 0xc3, 109 0x7f, 0x3d, 0x51, 0xd2, 0xb4, 0x05, 0x48, 0xec, 110 0x55, 0x91, 0x4f, 0x0d 111 }, 112 .len = 20, 113 }, 114 }; 115 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, 120 .auth = { 121 .algo = RTE_CRYPTO_AUTH_SHA224_HMAC, 122 }, 123 .input = { 124 .data = { 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 141 142 }, 143 .len = 128, 144 }, 145 .key = { 146 .data = { 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, 153 0x0a, 0xe2 154 }, 155 .len = 50, 156 }, 157 .digest = { 158 .data = { 159 0x33, 0xf1, 0x7a, 0xc8, 0xa5, 0xc6, 0xb5, 0x25, 160 0xdb, 0x8b, 0x86, 0x44, 0xb6, 0xab 161 162 }, 163 .len = 14, 164 }, 165 }; 166 167 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, 172 .auth = { 173 .algo = RTE_CRYPTO_AUTH_SHA256_HMAC, 174 }, 175 .input = { 176 .data = { 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 193 }, 194 .len = 128, 195 }, 196 .key = { 197 .data = { 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 203 }, 204 .len = 40, 205 }, 206 .digest = { 207 .data = { 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 212 }, 213 .len = 32, 214 }, 215 }; 216 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, 222 .auth = { 223 .algo = RTE_CRYPTO_AUTH_SHA384_HMAC, 224 }, 225 .input = { 226 .data = { 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 243 }, 244 .len = 128, 245 }, 246 .key = { 247 .data = { 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, 254 0xf8, 0xe1 255 }, 256 .len = 50, 257 }, 258 .digest = { 259 .data = { 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 265 }, 266 .len = 40, 267 }, 268 }; 269 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, 275 .auth = { 276 .algo = RTE_CRYPTO_AUTH_SHA512_HMAC, 277 }, 278 .input = { 279 .data = { 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 296 }, 297 .len = 128, 298 }, 299 .key = { 300 .data = { 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 314 }, 315 .len = 100, 316 }, 317 .digest = { 318 .data = { 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 324 }, 325 .len = 40, 326 }, 327 }; 328 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, 334 .auth = { 335 .algo = RTE_CRYPTO_AUTH_AES_CMAC, 336 }, 337 .input = { 338 .data = { 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 344 }, 345 .len = 37, 346 }, 347 .key = { 348 .data = { 349 0x18, 0x42, 0x15, 0x14, 0x5d, 0xa4, 0x9d, 0xb4, 350 0x17, 0xe8, 0xbd, 0xd5, 0x73, 0xd6, 0x28, 0x2d 351 }, 352 .len = 16, 353 }, 354 .digest = { 355 .data = { 356 0x8d, 0xa8, 0xcc, 0xa9, 0xb3, 0x6f, 0x68, 0x57, 357 0x1c, 0x6c, 0x0e, 0x40, 0xa3, 0xf4, 0x10 358 }, 359 .len = 15, 360 }, 361 }; 362 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, 368 .iv = { 369 .data = { 370 0x00, 0x50, 0x30, 0xF1, 0x84, 0x44, 0x08, 0xB5, 371 0x03, 0x97, 0x76, 0xE7, 0x0C 372 }, 373 .len = 13, 374 }, 375 .aead = { 376 .algo = RTE_CRYPTO_AEAD_AES_CCM, 377 .aad = { 378 .data = { 379 /* 18 bytes padding for AAD */ 380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 381 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 382 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 386 }, 387 .len = 22, 388 }, 389 }, 390 .input = { 391 .data = { 392 0xF8, 0xBA, 0x1A, 0x55, 0xD0, 0x2F, 0x85, 0xAE, 393 0x96, 0x7B, 0xB6, 0x2F, 0xB6, 0xCD, 0xA8, 0xEB, 394 0x7E, 0x78, 0xA0, 0x50 395 }, 396 .len = 20, 397 }, 398 .key = { 399 .data = { 400 0xC9, 0x7C, 0x1F, 0x67, 0xCE, 0x37, 0x11, 0x85, 401 0x51, 0x4A, 0x8A, 0x19, 0xF2, 0xBD, 0xD5, 0x2F 402 }, 403 .len = 16, 404 }, 405 .output = { 406 .data = { 407 0xF3, 0xD0, 0xA2, 0xFE, 0x9A, 0x3D, 0xBF, 0x23, 408 0x42, 0xA6, 0x43, 0xE4, 0x32, 0x46, 0xE8, 0x0C, 409 0x3C, 0x04, 0xD0, 0x19 410 }, 411 .len = 20, 412 }, 413 .digest = { 414 .data = { 415 0x78, 0x45, 0xCE, 0x0B, 0x16, 0xF9, 0x76, 0x23 416 }, 417 .len = 8, 418 }, 419 }; 420 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, 426 427 .iv = { 428 .data = { 429 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 430 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 431 }, 432 .len = 16, 433 }, 434 .cipher = { 435 .algo = RTE_CRYPTO_CIPHER_AES_CBC, 436 }, 437 .input = { 438 .data = { 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, 443 }, 444 .len = 32, 445 }, 446 .key = { 447 .data = { 448 0xE4, 0x23, 0x33, 0x8A, 0x35, 0x64, 0x61, 0xE2, 449 0x49, 0x03, 0xDD, 0xC6, 0xB8, 0xCA, 0x55, 0x7A 450 }, 451 .len = 16, 452 }, 453 .output = { 454 .data = { 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, 459 }, 460 .len = 32, 461 }, 462 }; 463 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, 468 469 .iv = { 470 .data = { 471 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 472 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 473 }, 474 .len = 16, 475 }, 476 .cipher = { 477 .algo = RTE_CRYPTO_CIPHER_AES_CBC, 478 }, 479 .input = { 480 .data = { 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, 485 }, 486 .len = 32, 487 }, 488 .key = { 489 .data = { 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 493 }, 494 .len = 24, 495 }, 496 .output = { 497 .data = { 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, 502 }, 503 .len = 32, 504 }, 505 }; 506 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, 512 513 .iv = { 514 .data = { 515 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 516 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F 517 }, 518 .len = 16, 519 }, 520 .cipher = { 521 .algo = RTE_CRYPTO_CIPHER_AES_CBC, 522 }, 523 .input = { 524 .data = { 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, 529 }, 530 .len = 32, 531 }, 532 .key = { 533 .data = { 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 538 }, 539 .len = 32, 540 }, 541 .output = { 542 .data = { 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, 547 }, 548 .len = 32, 549 }, 550 }; 551 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, 557 .iv = { 558 .data = { 559 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 560 }, 561 .len = 8, 562 }, 563 .cipher = { 564 .algo = RTE_CRYPTO_CIPHER_3DES_CBC, 565 }, 566 .input = { 567 .data = { 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, 572 }, 573 .len = 32, 574 }, 575 .key = { 576 .data = { 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 580 }, 581 .len = 24, 582 }, 583 .output = { 584 .data = { 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, 589 }, 590 .len = 32, 591 }, 592 }; 593 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, 598 599 .iv = { 600 .data = { 601 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07 602 }, 603 .len = 8, 604 }, 605 .cipher = { 606 .algo = RTE_CRYPTO_CIPHER_3DES_CBC, 607 }, 608 .input = { 609 .data = { 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, 614 }, 615 .len = 32, 616 }, 617 .key = { 618 .data = { 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 622 }, 623 .len = 24, 624 }, 625 .output = { 626 .data = { 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, 631 }, 632 .len = 32, 633 }, 634 }; 635 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, 641 642 .iv = { 643 .data = { 644 0x5a, 0xdb, 0x96, 0x09, 0xdb, 0xae, 0xb5, 0x8c, 645 0xbd, 0x6e, 0x72, 0x75 646 }, 647 .len = 12, 648 }, 649 .aead = { 650 .algo = RTE_CRYPTO_AEAD_AES_GCM, 651 .aad = { 652 .data = { 653 0x88, 0x31, 0x9d, 0x6e, 0x1d, 0x3f, 0xfa, 0x5f, 654 0x98, 0x71, 0x99, 0x16, 0x6c, 0x8a, 0x9b, 0x56, 655 0xc2, 0xae, 0xba, 0x5a 656 }, 657 .len = 20, 658 }, 659 }, 660 .input = { 661 .data = { 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, 668 0xbe, 0xa0, 0x63 669 }, 670 .len = 51, 671 }, 672 .key = { 673 .data = { 674 0xfe, 0x47, 0xfc, 0xce, 0x5f, 0xc3, 0x26, 0x65, 675 0xd2, 0xae, 0x39, 0x9e, 0x4e, 0xec, 0x72, 0xba 676 }, 677 .len = 16, 678 }, 679 .output = { 680 .data = { 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, 687 0xe5, 0xdb, 0x3e 688 }, 689 .len = 51, 690 }, 691 .digest = { 692 .data = { 693 0x29, 0x1e, 0xf1, 0x98, 0x2e, 0x4d, 0xef, 0xed, 694 0xaa, 0x22, 0x49, 0xf8, 0x98, 0x55, 0x6b, 0x47 695 }, 696 .len = 16, 697 }, 698 }; 699 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", 704 .iv = { 705 .data = { 706 0x0b, 0xd4, 0x4f, 0xf4, 0xd2, 0x0c, 0x15, 0xd0, 707 0x4f, 0xc6, 0x1e, 0xe7 708 }, 709 .len = 12, 710 }, 711 .aead = { 712 .algo = RTE_CRYPTO_AEAD_AES_GCM, 713 .aad = { 714 .data = { 715 0x9e, 0xa4, 0x2c, 0x50, 0xa7, 0xfd, 0xb8, 0x5e, 716 0x14, 0x1a, 0xa0, 0x84, 0xb4, 0x6b, 0xde, 0x12 717 }, 718 .len = 16, 719 }, 720 }, 721 .input = { 722 .data = { 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 727 }, 728 .len = 32, 729 }, 730 .key = { 731 .data = { 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 735 }, 736 .len = 24, 737 }, 738 .output = { 739 .data = { 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 744 }, 745 .len = 32, 746 }, 747 .digest = { 748 .data = { 749 0xde, 0x41, 0x45, 0x92, 0xd7, 0x7f, 0x2f, 0x0b, 750 0x50, 0xdf, 0x4a, 0xec, 0x71, 0x4f, 0xad, 0x43 751 }, 752 .len = 16, 753 }, 754 }; 755 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", 760 .iv = { 761 .data = { 762 0x5c, 0x1b, 0x21, 0xc8, 0x99, 0x8e, 0xd6, 0x29, 763 0x90, 0x06, 0xd3, 0xf9 764 }, 765 .len = 12, 766 }, 767 .aead = { 768 .algo = RTE_CRYPTO_AEAD_AES_GCM, 769 .aad = { 770 .data = { 771 0x22, 0xed, 0x23, 0x59, 0x46, 0x23, 0x5a, 0x85, 772 0xa4, 0x5b, 0xc5, 0xfa, 0xd7, 0x14, 0x0b, 0xfa 773 }, 774 .len = 16, 775 }, 776 }, 777 .input = { 778 .data = { 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 783 }, 784 .len = 32, 785 }, 786 .key = { 787 .data = { 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 792 }, 793 .len = 32, 794 }, 795 .output = { 796 .data = { 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 801 }, 802 .len = 32, 803 }, 804 .digest = { 805 .data = { 806 0x1f, 0xbf, 0x49, 0xcc, 0x46, 0xf4, 0x58, 0xbf, 807 0x6e, 0x88, 0xf6, 0x37, 0x09, 0x75, 0xe6, 0xd4 808 }, 809 .len = 16, 810 }, 811 }; 812 813 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, 819 820 .iv = { 821 .data = { 822 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 823 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF 824 }, 825 .len = 16, 826 }, 827 .cipher = { 828 .algo = RTE_CRYPTO_CIPHER_AES_CTR, 829 }, 830 .input = { 831 .data = { 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, 836 }, 837 .len = 32, 838 }, 839 .key = { 840 .data = { 841 0x2B, 0x7E, 0x15, 0x16, 0x28, 0xAE, 0xD2, 0xA6, 842 0xAB, 0xF7, 0x15, 0x88, 0x09, 0xCF, 0x4F, 0x3C 843 }, 844 .len = 16, 845 }, 846 .output = { 847 .data = { 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, 852 }, 853 .len = 32, 854 }, 855 }; 856 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, 861 862 .iv = { 863 .data = { 864 0x3F, 0x69, 0xA8, 0xCD, 0xE8, 0xF0, 0xEF, 0x40, 865 0xB8, 0x7A, 0x4B, 0xED, 0x2B, 0xAF, 0xBF, 0x57 866 }, 867 .len = 16, 868 }, 869 .cipher = { 870 .algo = RTE_CRYPTO_CIPHER_AES_CTR, 871 }, 872 .input = { 873 .data = { 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, 878 }, 879 .len = 32, 880 }, 881 .key = { 882 .data = { 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 886 }, 887 .len = 24, 888 }, 889 .output = { 890 .data = { 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, 895 }, 896 .len = 32, 897 }, 898 }; 899 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, 904 905 .iv = { 906 .data = { 907 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 908 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF 909 }, 910 .len = 16, 911 }, 912 .cipher = { 913 .algo = RTE_CRYPTO_CIPHER_AES_CTR, 914 }, 915 .input = { 916 .data = { 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, 921 }, 922 .len = 32, 923 }, 924 .key = { 925 .data = { 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 930 }, 931 .len = 32, 932 }, 933 .output = { 934 .data = { 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, 939 }, 940 .len = 32, 941 }, 942 }; 943 944 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, 965 }; 966 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; 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 *, struct rte_cryptodev_sym_session *, 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 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, PMD, "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, 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); 1047 return -EACCES; 1048 } 1049 1050 return 0; 1051 } 1052 1053 static int 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, PMD, "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, 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); 1103 return -EACCES; 1104 } 1105 1106 return 0; 1107 } 1108 1109 static int 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, PMD, "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, PMD, 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 1173 prepare_cipher_op(struct rte_crypto_op *op, 1174 struct rte_mbuf *mbuf, 1175 struct rte_cryptodev_sym_session *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, PMD, "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 1212 prepare_auth_op(struct rte_crypto_op *op, 1213 struct rte_mbuf *mbuf, 1214 struct rte_cryptodev_sym_session *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, PMD, "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, PMD, "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 1240 if (dir == self_test_dir_dec_auth_verify) 1241 memcpy(dst + vec->input.len, vec->digest.data, vec->digest.len); 1242 1243 rte_crypto_op_attach_sym_session(op, session); 1244 1245 return 0; 1246 } 1247 1248 static int 1249 prepare_aead_op(struct rte_crypto_op *op, 1250 struct rte_mbuf *mbuf, 1251 struct rte_cryptodev_sym_session *session, 1252 uint32_t dir, 1253 struct fips_dev_self_test_vector *vec) 1254 { 1255 struct rte_crypto_sym_op *sym = op->sym; 1256 uint8_t *iv = rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFF); 1257 uint8_t *dst; 1258 const uint8_t *src; 1259 uint32_t len; 1260 1261 if (dir == self_test_dir_enc_auth_gen) { 1262 len = vec->input.len; 1263 src = vec->input.data; 1264 } else { 1265 len = vec->output.len; 1266 src = vec->output.data; 1267 } 1268 1269 if (vec->aead.algo == RTE_CRYPTO_AEAD_AES_CCM) 1270 memcpy(iv + 1, vec->iv.data, vec->iv.len); 1271 else 1272 memcpy(iv, vec->iv.data, vec->iv.len); 1273 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); 1277 return -ENOMEM; 1278 } 1279 1280 dst = (uint8_t *)rte_pktmbuf_append(mbuf, len + vec->digest.len); 1281 if (!dst) { 1282 RTE_LOG(ERR, PMD, "Error %i: MBUF too small\n", -ENOMEM); 1283 return -ENOMEM; 1284 } 1285 1286 sym->m_src = mbuf; 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); 1292 1293 if (dir == self_test_dir_dec_auth_verify) 1294 memcpy(sym->aead.digest.data, vec->digest.data, vec->digest.len); 1295 1296 rte_crypto_op_attach_sym_session(op, session); 1297 1298 return 0; 1299 } 1300 1301 static int 1302 check_cipher_result(struct rte_crypto_op *op, 1303 struct fips_dev_self_test_vector *vec, 1304 uint32_t dir) 1305 { 1306 struct rte_mbuf *mbuf = op->sym->m_src; 1307 uint8_t *data; 1308 const uint8_t *src; 1309 uint32_t len, src_len; 1310 int ret; 1311 1312 if (dir == self_test_dir_enc_auth_gen) { 1313 src = vec->output.data; 1314 src_len = vec->output.len; 1315 } else { 1316 src = vec->input.data; 1317 src_len = vec->input.len; 1318 } 1319 1320 GET_MBUF_DATA(data, len, mbuf); 1321 if (len != src_len) 1322 return -1; 1323 1324 ret = memcmp(data, src, src_len); 1325 if (ret != 0) 1326 return -1; 1327 1328 return 0; 1329 } 1330 1331 static int 1332 check_auth_result(struct rte_crypto_op *op, 1333 struct fips_dev_self_test_vector *vec, 1334 uint32_t dir) 1335 { 1336 struct rte_mbuf *mbuf = op->sym->m_src; 1337 uint8_t *data; 1338 uint32_t len; 1339 int ret; 1340 1341 GET_MBUF_DATA(data, len, mbuf); 1342 if (len != vec->input.len + vec->digest.len) 1343 return -1; 1344 1345 if (dir == self_test_dir_enc_auth_gen) { 1346 data += vec->input.len; 1347 ret = memcmp(data, vec->digest.data, vec->digest.len); 1348 if (ret != 0) 1349 return -1; 1350 } 1351 1352 return 0; 1353 } 1354 1355 static int 1356 check_aead_result(struct rte_crypto_op *op, 1357 struct fips_dev_self_test_vector *vec, 1358 uint32_t dir) 1359 { 1360 struct rte_mbuf *mbuf = op->sym->m_src; 1361 uint8_t *data; 1362 const uint8_t *src; 1363 uint32_t len, src_len; 1364 int ret; 1365 1366 if (dir == self_test_dir_enc_auth_gen) { 1367 src = vec->output.data; 1368 src_len = vec->output.len; 1369 } else { 1370 src = vec->input.data; 1371 src_len = vec->input.len; 1372 } 1373 1374 GET_MBUF_DATA(data, len, mbuf); 1375 if (len != src_len + vec->digest.len) 1376 return -1; 1377 1378 ret = memcmp(data, src, src_len); 1379 if (ret != 0) 1380 return -1; 1381 1382 if (dir == self_test_dir_enc_auth_gen) { 1383 data += src_len; 1384 ret = memcmp(data, vec->digest.data, vec->digest.len); 1385 if (ret != 0) 1386 return -1; 1387 } 1388 1389 return 0; 1390 } 1391 1392 static void 1393 init_test_op(struct fips_dev_self_test_ops *test_ops, 1394 struct fips_dev_self_test_vector *vec) 1395 { 1396 if (test_ops->last_operation_type == vec->operation_type) 1397 return; 1398 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; 1404 break; 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; 1409 break; 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; 1414 break; 1415 default: 1416 break; 1417 } 1418 1419 test_ops->last_operation_type = vec->operation_type; 1420 } 1421 1422 static int 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, 1427 uint32_t dir, 1428 uint32_t negative_test) 1429 { 1430 struct rte_crypto_sym_xform xform; 1431 struct rte_cryptodev_sym_session *sess; 1432 uint16_t n_deqd; 1433 uint8_t key[256]; 1434 int ret; 1435 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; 1439 1440 ret = test_ops->prepare_xform(dev_id, &xform, vec, dir, key, 1441 negative_test); 1442 if (ret < 0) { 1443 RTE_LOG(ERR, PMD, "Error %i: Prepare Xform\n", ret); 1444 return ret; 1445 } 1446 1447 sess = rte_cryptodev_sym_session_create(env->sess_pool); 1448 if (!sess) 1449 return -ENOMEM; 1450 1451 ret = rte_cryptodev_sym_session_init(dev_id, 1452 sess, &xform, env->sess_priv_pool); 1453 if (ret < 0) { 1454 RTE_LOG(ERR, PMD, "Error %i: Init session\n", ret); 1455 return ret; 1456 } 1457 1458 ret = test_ops->prepare_op(env->op, env->mbuf, sess, dir, vec); 1459 if (ret < 0) { 1460 RTE_LOG(ERR, PMD, "Error %i: Prepare op\n", ret); 1461 return ret; 1462 } 1463 1464 if (rte_cryptodev_enqueue_burst(dev_id, 0, &env->op, 1) < 1) { 1465 RTE_LOG(ERR, PMD, "Error: Failed enqueue\n"); 1466 return ret; 1467 } 1468 1469 do { 1470 struct rte_crypto_op *deqd_op; 1471 1472 n_deqd = rte_cryptodev_dequeue_burst(dev_id, 0, &deqd_op, 1473 1); 1474 } while (n_deqd == 0); 1475 1476 rte_cryptodev_sym_session_clear(dev_id, sess); 1477 rte_cryptodev_sym_session_free(sess); 1478 1479 if (env->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) 1480 return -1; 1481 1482 return test_ops->check_result(env->op, vec, dir); 1483 } 1484 1485 1486 static void 1487 fips_dev_auto_test_uninit(uint8_t dev_id, 1488 struct fips_dev_auto_test_env *env) 1489 { 1490 struct rte_cryptodev *dev = rte_cryptodev_pmd_get_dev(dev_id); 1491 uint32_t i; 1492 1493 if (!dev) 1494 return; 1495 1496 if (env->mbuf) 1497 rte_pktmbuf_free(env->mbuf); 1498 if (env->op) 1499 rte_crypto_op_free(env->op); 1500 if (env->mpool) 1501 rte_mempool_free(env->mpool); 1502 if (env->op_pool) 1503 rte_mempool_free(env->op_pool); 1504 if (env->sess_pool) 1505 rte_mempool_free(env->sess_pool); 1506 if (env->sess_priv_pool) 1507 rte_mempool_free(env->sess_priv_pool); 1508 1509 if (dev->data->dev_started) 1510 rte_cryptodev_stop(dev_id); 1511 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; 1518 } 1519 } 1520 1521 static int 1522 fips_dev_auto_test_init(uint8_t dev_id, struct fips_dev_auto_test_env *env) 1523 { 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); 1527 char name[128]; 1528 int ret; 1529 1530 ret = rte_cryptodev_configure(dev_id, &conf); 1531 if (ret < 0) 1532 return ret; 1533 1534 memset(name, 0, 128); 1535 snprintf(name, 128, "%s%u", "SELF_TEST_MEMPOOL", dev_id); 1536 1537 memset(env, 0, sizeof(*env)); 1538 1539 env->mpool = rte_pktmbuf_pool_create(name, 128, 0, 0, 1540 UINT16_MAX, rte_cryptodev_socket_id(dev_id)); 1541 if (!env->mpool) { 1542 ret = -ENOMEM; 1543 goto error_exit; 1544 } 1545 1546 memset(name, 0, 128); 1547 snprintf(name, 128, "%s%u", "SELF_TEST_OP_POOL", dev_id); 1548 1549 env->op_pool = rte_crypto_op_pool_create( 1550 name, 1551 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 1552 16, 0, 1553 16, 1554 rte_socket_id()); 1555 if (!env->op_pool) { 1556 ret = -ENOMEM; 1557 goto error_exit; 1558 } 1559 1560 memset(name, 0, 128); 1561 snprintf(name, 128, "%s%u", "SELF_TEST_SESS_POOL", dev_id); 1562 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) { 1566 ret = -ENOMEM; 1567 goto error_exit; 1568 } 1569 1570 memset(name, 0, 128); 1571 snprintf(name, 128, "%s%u", "SELF_TEST_SESS_PRIV_POOL", dev_id); 1572 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) { 1577 ret = -ENOMEM; 1578 goto error_exit; 1579 } 1580 1581 qp_conf.mp_session = env->sess_pool; 1582 qp_conf.mp_session_private = env->sess_priv_pool; 1583 1584 ret = rte_cryptodev_queue_pair_setup(dev_id, 0, &qp_conf, 1585 rte_cryptodev_socket_id(dev_id)); 1586 if (ret < 0) 1587 goto error_exit; 1588 1589 env->mbuf = rte_pktmbuf_alloc(env->mpool); 1590 if (!env->mbuf) { 1591 ret = -ENOMEM; 1592 goto error_exit; 1593 } 1594 1595 env->op = rte_crypto_op_alloc(env->op_pool, 1596 RTE_CRYPTO_OP_TYPE_SYMMETRIC); 1597 if (!env->op) { 1598 ret = -ENOMEM; 1599 goto error_exit; 1600 } 1601 1602 ret = rte_cryptodev_start(dev_id); 1603 if (ret < 0) 1604 goto error_exit; 1605 1606 1607 return 0; 1608 1609 error_exit: 1610 1611 fips_dev_auto_test_uninit(dev_id, env); 1612 1613 return ret; 1614 } 1615 1616 int 1617 fips_dev_self_test(uint8_t dev_id, 1618 struct fips_dev_broken_test_config *config) 1619 { 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; 1623 int ret; 1624 1625 ret = fips_dev_auto_test_init(dev_id, &env); 1626 if (ret < 0) { 1627 RTE_LOG(ERR, PMD, "Failed to init self-test for PMD %u\n", 1628 dev_id); 1629 return ret; 1630 } 1631 1632 for (i = 0; i < RTE_DIM(self_test_vectors); i++) { 1633 struct fips_dev_self_test_vector *vec = 1634 self_test_vectors[i]; 1635 1636 init_test_op(&test_ops, vec); 1637 1638 for (j = 0; j < self_test_dir_max; j++) { 1639 if (!config) 1640 negative_test = 0; 1641 else { 1642 if ((config->expect_fail_test_idx == i) && 1643 (config->expect_fail_dir == j)) 1644 negative_test = 1; 1645 else 1646 negative_test = 0; 1647 } 1648 1649 RTE_LOG(INFO, PMD, "Testing (ID %u) %s %s%s...\n", 1650 i, 1651 vec->name, 1652 j == self_test_dir_enc_auth_gen ? 1653 "Encrypt" : "Decrypt", 1654 negative_test ? " (Expect Fail)" : ""); 1655 1656 ret = run_single_test(dev_id, vec, &test_ops, 1657 &env, j, negative_test); 1658 switch (ret) { 1659 case 0: 1660 if (!negative_test) 1661 break; 1662 ret = -1; 1663 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n", 1664 dev_id, vec->name, 1665 j == self_test_dir_enc_auth_gen ? 1666 "Encrypt" : "Decrypt"); 1667 goto error_exit; 1668 case -EACCES: 1669 RTE_LOG(ERR, PMD, "Not supported by %s. Skip\n", 1670 rte_cryptodev_name_get(dev_id)); 1671 ret = 0; 1672 break; 1673 default: 1674 RTE_LOG(ERR, PMD, "PMD %u Failed test %s %s\n", 1675 dev_id, vec->name, 1676 j == self_test_dir_enc_auth_gen ? 1677 "Encrypt" : "Decrypt"); 1678 goto error_exit; 1679 } 1680 } 1681 } 1682 1683 error_exit: 1684 fips_dev_auto_test_uninit(dev_id, &env); 1685 1686 if (ret == 0) { 1687 RTE_LOG(INFO, PMD, "PMD %u finished self-test successfully\n", 1688 dev_id); 1689 } 1690 1691 return ret; 1692 } 1693