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