test_driver_aead.c (18101B)
1 /* 2 * Test driver for AEAD entry points. 3 */ 4 /* Copyright The Mbed TLS Contributors 5 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 6 */ 7 8 #include <test/helpers.h> 9 10 #if defined(PSA_CRYPTO_DRIVER_TEST) 11 #include "psa_crypto_aead.h" 12 #include "psa_crypto_core.h" 13 14 #include "test/drivers/aead.h" 15 16 #include "mbedtls/constant_time.h" 17 18 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) 19 #if MBEDTLS_VERSION_MAJOR < 4 20 #include "libtestdriver1/library/psa_crypto_aead.h" 21 #else 22 #include "libtestdriver1/tf-psa-crypto/drivers/builtin/src/psa_crypto_aead.h" 23 #endif 24 #endif 25 26 mbedtls_test_driver_aead_hooks_t 27 mbedtls_test_driver_aead_hooks = MBEDTLS_TEST_DRIVER_AEAD_INIT; 28 29 psa_status_t mbedtls_test_transparent_aead_encrypt( 30 const psa_key_attributes_t *attributes, 31 const uint8_t *key_buffer, size_t key_buffer_size, 32 psa_algorithm_t alg, 33 const uint8_t *nonce, size_t nonce_length, 34 const uint8_t *additional_data, size_t additional_data_length, 35 const uint8_t *plaintext, size_t plaintext_length, 36 uint8_t *ciphertext, size_t ciphertext_size, size_t *ciphertext_length) 37 { 38 mbedtls_test_driver_aead_hooks.hits_encrypt++; 39 40 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 41 mbedtls_test_driver_aead_hooks.driver_status = 42 mbedtls_test_driver_aead_hooks.forced_status; 43 } else { 44 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 45 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 46 mbedtls_test_driver_aead_hooks.driver_status = 47 libtestdriver1_mbedtls_psa_aead_encrypt( 48 (const libtestdriver1_psa_key_attributes_t *) attributes, 49 key_buffer, key_buffer_size, 50 alg, 51 nonce, nonce_length, 52 additional_data, additional_data_length, 53 plaintext, plaintext_length, 54 ciphertext, ciphertext_size, ciphertext_length); 55 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 56 mbedtls_test_driver_aead_hooks.driver_status = 57 mbedtls_psa_aead_encrypt( 58 attributes, key_buffer, key_buffer_size, 59 alg, 60 nonce, nonce_length, 61 additional_data, additional_data_length, 62 plaintext, plaintext_length, 63 ciphertext, ciphertext_size, ciphertext_length); 64 #else 65 (void) attributes; 66 (void) key_buffer; 67 (void) key_buffer_size; 68 (void) alg; 69 (void) nonce; 70 (void) nonce_length; 71 (void) additional_data; 72 (void) additional_data_length; 73 (void) plaintext; 74 (void) plaintext_length; 75 (void) ciphertext; 76 (void) ciphertext_size; 77 (void) ciphertext_length; 78 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 79 #endif 80 } 81 82 return mbedtls_test_driver_aead_hooks.driver_status; 83 } 84 85 psa_status_t mbedtls_test_transparent_aead_decrypt( 86 const psa_key_attributes_t *attributes, 87 const uint8_t *key_buffer, size_t key_buffer_size, 88 psa_algorithm_t alg, 89 const uint8_t *nonce, size_t nonce_length, 90 const uint8_t *additional_data, size_t additional_data_length, 91 const uint8_t *ciphertext, size_t ciphertext_length, 92 uint8_t *plaintext, size_t plaintext_size, size_t *plaintext_length) 93 { 94 mbedtls_test_driver_aead_hooks.hits_decrypt++; 95 96 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 97 mbedtls_test_driver_aead_hooks.driver_status = 98 mbedtls_test_driver_aead_hooks.forced_status; 99 } else { 100 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 101 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 102 mbedtls_test_driver_aead_hooks.driver_status = 103 libtestdriver1_mbedtls_psa_aead_decrypt( 104 (const libtestdriver1_psa_key_attributes_t *) attributes, 105 key_buffer, key_buffer_size, 106 alg, 107 nonce, nonce_length, 108 additional_data, additional_data_length, 109 ciphertext, ciphertext_length, 110 plaintext, plaintext_size, plaintext_length); 111 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 112 mbedtls_test_driver_aead_hooks.driver_status = 113 mbedtls_psa_aead_decrypt( 114 attributes, key_buffer, key_buffer_size, 115 alg, 116 nonce, nonce_length, 117 additional_data, additional_data_length, 118 ciphertext, ciphertext_length, 119 plaintext, plaintext_size, plaintext_length); 120 #else 121 (void) attributes; 122 (void) key_buffer; 123 (void) key_buffer_size; 124 (void) alg; 125 (void) nonce; 126 (void) nonce_length; 127 (void) additional_data; 128 (void) additional_data_length; 129 (void) ciphertext; 130 (void) ciphertext_length; 131 (void) plaintext; 132 (void) plaintext_size; 133 (void) plaintext_length; 134 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 135 #endif 136 } 137 138 return mbedtls_test_driver_aead_hooks.driver_status; 139 } 140 141 psa_status_t mbedtls_test_transparent_aead_encrypt_setup( 142 mbedtls_transparent_test_driver_aead_operation_t *operation, 143 const psa_key_attributes_t *attributes, 144 const uint8_t *key_buffer, size_t key_buffer_size, 145 psa_algorithm_t alg) 146 { 147 mbedtls_test_driver_aead_hooks.hits_encrypt_setup++; 148 149 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 150 mbedtls_test_driver_aead_hooks.driver_status = 151 mbedtls_test_driver_aead_hooks.forced_status; 152 } else if (!MBEDTLS_TEST_OBJECT_IS_ALL_ZERO(operation)) { 153 mbedtls_test_driver_aead_hooks.driver_status = 154 PSA_ERROR_TEST_DETECTED_BAD_INITIALIZATION; 155 } else { 156 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 157 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 158 mbedtls_test_driver_aead_hooks.driver_status = 159 libtestdriver1_mbedtls_psa_aead_encrypt_setup(operation, 160 (const libtestdriver1_psa_key_attributes_t 161 *) attributes, 162 key_buffer, 163 key_buffer_size, alg); 164 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 165 mbedtls_test_driver_aead_hooks.driver_status = 166 mbedtls_psa_aead_encrypt_setup(operation, attributes, key_buffer, 167 key_buffer_size, alg); 168 #else 169 (void) operation; 170 (void) attributes; 171 (void) key_buffer; 172 (void) key_buffer_size; 173 (void) alg; 174 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 175 #endif 176 } 177 178 return mbedtls_test_driver_aead_hooks.driver_status; 179 } 180 181 psa_status_t mbedtls_test_transparent_aead_decrypt_setup( 182 mbedtls_transparent_test_driver_aead_operation_t *operation, 183 const psa_key_attributes_t *attributes, 184 const uint8_t *key_buffer, size_t key_buffer_size, 185 psa_algorithm_t alg) 186 { 187 mbedtls_test_driver_aead_hooks.hits_decrypt_setup++; 188 189 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 190 mbedtls_test_driver_aead_hooks.driver_status = 191 mbedtls_test_driver_aead_hooks.forced_status; 192 } else if (!MBEDTLS_TEST_OBJECT_IS_ALL_ZERO(operation)) { 193 mbedtls_test_driver_aead_hooks.driver_status = 194 PSA_ERROR_TEST_DETECTED_BAD_INITIALIZATION; 195 } else { 196 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 197 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 198 mbedtls_test_driver_aead_hooks.driver_status = 199 libtestdriver1_mbedtls_psa_aead_decrypt_setup(operation, 200 (const libtestdriver1_psa_key_attributes_t 201 *) attributes, 202 key_buffer, key_buffer_size, alg); 203 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 204 mbedtls_test_driver_aead_hooks.driver_status = 205 mbedtls_psa_aead_decrypt_setup(operation, attributes, key_buffer, 206 key_buffer_size, alg); 207 #else 208 (void) operation; 209 (void) attributes; 210 (void) key_buffer; 211 (void) key_buffer_size; 212 (void) alg; 213 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 214 #endif 215 } 216 217 return mbedtls_test_driver_aead_hooks.driver_status; 218 } 219 220 psa_status_t mbedtls_test_transparent_aead_set_nonce( 221 mbedtls_transparent_test_driver_aead_operation_t *operation, 222 const uint8_t *nonce, 223 size_t nonce_length) 224 { 225 mbedtls_test_driver_aead_hooks.hits_set_nonce++; 226 227 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 228 mbedtls_test_driver_aead_hooks.driver_status = 229 mbedtls_test_driver_aead_hooks.forced_status; 230 } else { 231 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 232 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 233 mbedtls_test_driver_aead_hooks.driver_status = 234 libtestdriver1_mbedtls_psa_aead_set_nonce(operation, nonce, nonce_length); 235 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 236 mbedtls_test_driver_aead_hooks.driver_status = 237 mbedtls_psa_aead_set_nonce(operation, nonce, nonce_length); 238 #else 239 (void) operation; 240 (void) nonce; 241 (void) nonce_length; 242 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 243 #endif 244 } 245 246 return mbedtls_test_driver_aead_hooks.driver_status; 247 } 248 249 psa_status_t mbedtls_test_transparent_aead_set_lengths( 250 mbedtls_transparent_test_driver_aead_operation_t *operation, 251 size_t ad_length, 252 size_t plaintext_length) 253 { 254 mbedtls_test_driver_aead_hooks.hits_set_lengths++; 255 256 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 257 mbedtls_test_driver_aead_hooks.driver_status = 258 mbedtls_test_driver_aead_hooks.forced_status; 259 } else { 260 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 261 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 262 mbedtls_test_driver_aead_hooks.driver_status = 263 libtestdriver1_mbedtls_psa_aead_set_lengths(operation, ad_length, 264 plaintext_length); 265 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 266 mbedtls_test_driver_aead_hooks.driver_status = 267 mbedtls_psa_aead_set_lengths(operation, ad_length, 268 plaintext_length); 269 #else 270 (void) operation; 271 (void) ad_length; 272 (void) plaintext_length; 273 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 274 #endif 275 } 276 277 return mbedtls_test_driver_aead_hooks.driver_status; 278 } 279 280 psa_status_t mbedtls_test_transparent_aead_update_ad( 281 mbedtls_transparent_test_driver_aead_operation_t *operation, 282 const uint8_t *input, 283 size_t input_length) 284 { 285 mbedtls_test_driver_aead_hooks.hits_update_ad++; 286 287 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 288 mbedtls_test_driver_aead_hooks.driver_status = 289 mbedtls_test_driver_aead_hooks.forced_status; 290 } else { 291 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 292 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 293 mbedtls_test_driver_aead_hooks.driver_status = 294 libtestdriver1_mbedtls_psa_aead_update_ad(operation, input, input_length); 295 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 296 mbedtls_test_driver_aead_hooks.driver_status = 297 mbedtls_psa_aead_update_ad(operation, input, input_length); 298 #else 299 (void) operation; 300 (void) input; 301 (void) input_length; 302 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 303 #endif 304 } 305 306 return mbedtls_test_driver_aead_hooks.driver_status; 307 } 308 309 psa_status_t mbedtls_test_transparent_aead_update( 310 mbedtls_transparent_test_driver_aead_operation_t *operation, 311 const uint8_t *input, 312 size_t input_length, 313 uint8_t *output, 314 size_t output_size, 315 size_t *output_length) 316 { 317 mbedtls_test_driver_aead_hooks.hits_update++; 318 319 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 320 mbedtls_test_driver_aead_hooks.driver_status = 321 mbedtls_test_driver_aead_hooks.forced_status; 322 } else { 323 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 324 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 325 mbedtls_test_driver_aead_hooks.driver_status = 326 libtestdriver1_mbedtls_psa_aead_update(operation, input, 327 input_length, output, 328 output_size, output_length); 329 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 330 mbedtls_test_driver_aead_hooks.driver_status = 331 mbedtls_psa_aead_update(operation, input, input_length, output, 332 output_size, output_length); 333 #else 334 (void) operation; 335 (void) input; 336 (void) input_length; 337 (void) output; 338 (void) output_size; 339 (void) output_length; 340 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 341 #endif 342 } 343 344 return mbedtls_test_driver_aead_hooks.driver_status; 345 } 346 347 psa_status_t mbedtls_test_transparent_aead_finish( 348 mbedtls_transparent_test_driver_aead_operation_t *operation, 349 uint8_t *ciphertext, 350 size_t ciphertext_size, 351 size_t *ciphertext_length, 352 uint8_t *tag, 353 size_t tag_size, 354 size_t *tag_length) 355 { 356 mbedtls_test_driver_aead_hooks.hits_finish++; 357 358 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 359 mbedtls_test_driver_aead_hooks.driver_status = 360 mbedtls_test_driver_aead_hooks.forced_status; 361 } else { 362 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 363 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 364 mbedtls_test_driver_aead_hooks.driver_status = 365 libtestdriver1_mbedtls_psa_aead_finish(operation, ciphertext, 366 ciphertext_size, ciphertext_length, 367 tag, tag_size, tag_length); 368 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 369 mbedtls_test_driver_aead_hooks.driver_status = 370 mbedtls_psa_aead_finish(operation, ciphertext, ciphertext_size, 371 ciphertext_length, tag, tag_size, 372 tag_length); 373 #else 374 (void) operation; 375 (void) ciphertext; 376 (void) ciphertext_size; 377 (void) ciphertext_length; 378 (void) tag; 379 (void) tag_size; 380 (void) tag_length; 381 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 382 #endif 383 } 384 385 return mbedtls_test_driver_aead_hooks.driver_status; 386 } 387 388 psa_status_t mbedtls_test_transparent_aead_verify( 389 mbedtls_transparent_test_driver_aead_operation_t *operation, 390 uint8_t *plaintext, 391 size_t plaintext_size, 392 size_t *plaintext_length, 393 const uint8_t *tag, 394 size_t tag_length) 395 { 396 mbedtls_test_driver_aead_hooks.hits_verify++; 397 398 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 399 mbedtls_test_driver_aead_hooks.driver_status = 400 mbedtls_test_driver_aead_hooks.forced_status; 401 } else { 402 uint8_t check_tag[PSA_AEAD_TAG_MAX_SIZE]; 403 size_t check_tag_length = 0; 404 405 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 406 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 407 mbedtls_test_driver_aead_hooks.driver_status = 408 libtestdriver1_mbedtls_psa_aead_finish(operation, 409 plaintext, 410 plaintext_size, 411 plaintext_length, 412 check_tag, 413 sizeof(check_tag), 414 &check_tag_length); 415 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 416 mbedtls_test_driver_aead_hooks.driver_status = 417 mbedtls_psa_aead_finish(operation, 418 plaintext, 419 plaintext_size, 420 plaintext_length, 421 check_tag, 422 sizeof(check_tag), 423 &check_tag_length); 424 #else 425 (void) operation; 426 (void) plaintext; 427 (void) plaintext_size; 428 (void) plaintext_length; 429 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 430 #endif 431 432 if (mbedtls_test_driver_aead_hooks.driver_status == PSA_SUCCESS) { 433 if (tag_length != check_tag_length || 434 mbedtls_ct_memcmp(tag, check_tag, tag_length) 435 != 0) { 436 mbedtls_test_driver_aead_hooks.driver_status = 437 PSA_ERROR_INVALID_SIGNATURE; 438 } 439 } 440 441 mbedtls_platform_zeroize(check_tag, sizeof(check_tag)); 442 } 443 444 return mbedtls_test_driver_aead_hooks.driver_status; 445 } 446 447 psa_status_t mbedtls_test_transparent_aead_abort( 448 mbedtls_transparent_test_driver_aead_operation_t *operation) 449 { 450 mbedtls_test_driver_aead_hooks.hits_abort++; 451 452 if (mbedtls_test_driver_aead_hooks.forced_status != PSA_SUCCESS) { 453 mbedtls_test_driver_aead_hooks.driver_status = 454 mbedtls_test_driver_aead_hooks.forced_status; 455 } else { 456 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 457 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_AEAD) 458 mbedtls_test_driver_aead_hooks.driver_status = 459 libtestdriver1_mbedtls_psa_aead_abort(operation); 460 #elif defined(MBEDTLS_PSA_BUILTIN_AEAD) 461 mbedtls_test_driver_aead_hooks.driver_status = 462 mbedtls_psa_aead_abort(operation); 463 #else 464 (void) operation; 465 mbedtls_test_driver_aead_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; 466 #endif 467 } 468 469 return mbedtls_test_driver_aead_hooks.driver_status; 470 } 471 472 #endif /* PSA_CRYPTO_DRIVER_TEST */