test_suite_psa_crypto_memory.function (7375B)
1 /* BEGIN_HEADER */ 2 #include <stdint.h> 3 4 #include "common.h" 5 6 #include "psa/crypto.h" 7 8 #include "psa_crypto_core.h" 9 #include "psa_crypto_invasive.h" 10 11 #include "test/psa_crypto_helpers.h" 12 #include "test/memory.h" 13 14 /* Helper to fill a buffer with a data pattern. The pattern is not 15 * important, it just allows a basic check that the correct thing has 16 * been written, in a way that will detect an error in offset. */ 17 static void fill_buffer_pattern(uint8_t *buffer, size_t len) 18 { 19 for (size_t i = 0; i < len; i++) { 20 buffer[i] = (uint8_t) (i % 256); 21 } 22 } 23 /* END_HEADER */ 24 25 /* BEGIN_DEPENDENCIES 26 * depends_on:MBEDTLS_PSA_CRYPTO_C:MBEDTLS_TEST_HOOKS 27 * END_DEPENDENCIES 28 */ 29 30 /* BEGIN_CASE */ 31 void copy_input(int src_len, int dst_len, psa_status_t exp_status) 32 { 33 uint8_t *src_buffer = NULL; 34 uint8_t *dst_buffer = NULL; 35 psa_status_t status; 36 37 TEST_CALLOC(src_buffer, src_len); 38 TEST_CALLOC(dst_buffer, dst_len); 39 40 fill_buffer_pattern(src_buffer, src_len); 41 42 status = psa_crypto_copy_input(src_buffer, src_len, dst_buffer, dst_len); 43 TEST_EQUAL(status, exp_status); 44 45 if (exp_status == PSA_SUCCESS) { 46 MBEDTLS_TEST_MEMORY_UNPOISON(src_buffer, src_len); 47 /* Note: We compare the first src_len bytes of each buffer, as this is what was copied. */ 48 TEST_MEMORY_COMPARE(src_buffer, src_len, dst_buffer, src_len); 49 } 50 51 exit: 52 mbedtls_free(src_buffer); 53 mbedtls_free(dst_buffer); 54 } 55 /* END_CASE */ 56 57 /* BEGIN_CASE */ 58 void copy_output(int src_len, int dst_len, psa_status_t exp_status) 59 { 60 uint8_t *src_buffer = NULL; 61 uint8_t *dst_buffer = NULL; 62 psa_status_t status; 63 64 TEST_CALLOC(src_buffer, src_len); 65 TEST_CALLOC(dst_buffer, dst_len); 66 67 fill_buffer_pattern(src_buffer, src_len); 68 69 status = psa_crypto_copy_output(src_buffer, src_len, dst_buffer, dst_len); 70 TEST_EQUAL(status, exp_status); 71 72 if (exp_status == PSA_SUCCESS) { 73 MBEDTLS_TEST_MEMORY_UNPOISON(dst_buffer, dst_len); 74 /* Note: We compare the first src_len bytes of each buffer, as this is what was copied. */ 75 TEST_MEMORY_COMPARE(src_buffer, src_len, dst_buffer, src_len); 76 } 77 78 exit: 79 mbedtls_free(src_buffer); 80 mbedtls_free(dst_buffer); 81 } 82 /* END_CASE */ 83 84 /* BEGIN_CASE */ 85 void local_input_alloc(int input_len, psa_status_t exp_status) 86 { 87 uint8_t *input = NULL; 88 psa_crypto_local_input_t local_input; 89 psa_status_t status; 90 91 local_input.buffer = NULL; 92 93 TEST_CALLOC(input, input_len); 94 fill_buffer_pattern(input, input_len); 95 96 status = psa_crypto_local_input_alloc(input, input_len, &local_input); 97 TEST_EQUAL(status, exp_status); 98 99 if (exp_status == PSA_SUCCESS) { 100 MBEDTLS_TEST_MEMORY_UNPOISON(input, input_len); 101 if (input_len != 0) { 102 TEST_ASSERT(local_input.buffer != input); 103 } 104 TEST_MEMORY_COMPARE(input, input_len, 105 local_input.buffer, local_input.length); 106 } 107 108 exit: 109 mbedtls_free(local_input.buffer); 110 111 if (local_input.buffer != input) { 112 mbedtls_free(input); 113 } 114 } 115 /* END_CASE */ 116 117 /* BEGIN_CASE */ 118 void local_input_free(int input_len) 119 { 120 psa_crypto_local_input_t local_input; 121 122 local_input.buffer = NULL; 123 local_input.length = input_len; 124 TEST_CALLOC(local_input.buffer, local_input.length); 125 126 psa_crypto_local_input_free(&local_input); 127 128 TEST_ASSERT(local_input.buffer == NULL); 129 TEST_EQUAL(local_input.length, 0); 130 131 exit: 132 mbedtls_free(local_input.buffer); 133 local_input.buffer = NULL; 134 local_input.length = 0; 135 } 136 /* END_CASE */ 137 138 /* BEGIN_CASE */ 139 void local_input_round_trip() 140 { 141 psa_crypto_local_input_t local_input; 142 uint8_t input[200]; 143 psa_status_t status; 144 145 fill_buffer_pattern(input, sizeof(input)); 146 147 status = psa_crypto_local_input_alloc(input, sizeof(input), &local_input); 148 TEST_EQUAL(status, PSA_SUCCESS); 149 150 MBEDTLS_TEST_MEMORY_UNPOISON(input, sizeof(input)); 151 TEST_MEMORY_COMPARE(local_input.buffer, local_input.length, 152 input, sizeof(input)); 153 TEST_ASSERT(local_input.buffer != input); 154 155 psa_crypto_local_input_free(&local_input); 156 TEST_ASSERT(local_input.buffer == NULL); 157 TEST_EQUAL(local_input.length, 0); 158 } 159 /* END_CASE */ 160 161 /* BEGIN_CASE */ 162 void local_output_alloc(int output_len, psa_status_t exp_status) 163 { 164 uint8_t *output = NULL; 165 psa_crypto_local_output_t local_output; 166 psa_status_t status; 167 168 local_output.buffer = NULL; 169 170 TEST_CALLOC(output, output_len); 171 172 status = psa_crypto_local_output_alloc(output, output_len, &local_output); 173 TEST_EQUAL(status, exp_status); 174 175 if (exp_status == PSA_SUCCESS) { 176 TEST_ASSERT(local_output.original == output); 177 TEST_EQUAL(local_output.length, output_len); 178 } 179 180 exit: 181 mbedtls_free(local_output.buffer); 182 local_output.original = NULL; 183 local_output.buffer = NULL; 184 local_output.length = 0; 185 mbedtls_free(output); 186 output = NULL; 187 } 188 /* END_CASE */ 189 190 /* BEGIN_CASE */ 191 void local_output_free(int output_len, int original_is_null, 192 psa_status_t exp_status) 193 { 194 uint8_t *output = NULL; 195 uint8_t *buffer_copy_for_comparison = NULL; 196 psa_crypto_local_output_t local_output = PSA_CRYPTO_LOCAL_OUTPUT_INIT; 197 psa_status_t status; 198 199 if (!original_is_null) { 200 TEST_CALLOC(output, output_len); 201 } 202 TEST_CALLOC(buffer_copy_for_comparison, output_len); 203 TEST_CALLOC(local_output.buffer, output_len); 204 local_output.length = output_len; 205 local_output.original = output; 206 207 if (local_output.length != 0) { 208 fill_buffer_pattern(local_output.buffer, local_output.length); 209 memcpy(buffer_copy_for_comparison, local_output.buffer, local_output.length); 210 } 211 212 status = psa_crypto_local_output_free(&local_output); 213 TEST_EQUAL(status, exp_status); 214 215 if (exp_status == PSA_SUCCESS) { 216 MBEDTLS_TEST_MEMORY_UNPOISON(output, output_len); 217 TEST_ASSERT(local_output.buffer == NULL); 218 TEST_EQUAL(local_output.length, 0); 219 TEST_MEMORY_COMPARE(buffer_copy_for_comparison, output_len, 220 output, output_len); 221 } 222 223 exit: 224 mbedtls_free(output); 225 mbedtls_free(buffer_copy_for_comparison); 226 mbedtls_free(local_output.buffer); 227 local_output.length = 0; 228 } 229 /* END_CASE */ 230 231 /* BEGIN_CASE */ 232 void local_output_round_trip() 233 { 234 psa_crypto_local_output_t local_output; 235 uint8_t output[200]; 236 uint8_t *buffer_copy_for_comparison = NULL; 237 psa_status_t status; 238 239 status = psa_crypto_local_output_alloc(output, sizeof(output), &local_output); 240 TEST_EQUAL(status, PSA_SUCCESS); 241 TEST_ASSERT(local_output.buffer != output); 242 243 /* Simulate the function generating output */ 244 fill_buffer_pattern(local_output.buffer, local_output.length); 245 246 TEST_CALLOC(buffer_copy_for_comparison, local_output.length); 247 memcpy(buffer_copy_for_comparison, local_output.buffer, local_output.length); 248 249 TEST_EQUAL(psa_crypto_local_output_free(&local_output), PSA_SUCCESS); 250 TEST_ASSERT(local_output.buffer == NULL); 251 TEST_EQUAL(local_output.length, 0); 252 253 MBEDTLS_TEST_MEMORY_UNPOISON(output, sizeof(output)); 254 /* Check that the buffer was correctly copied back */ 255 TEST_MEMORY_COMPARE(output, sizeof(output), 256 buffer_copy_for_comparison, sizeof(output)); 257 258 exit: 259 mbedtls_free(buffer_copy_for_comparison); 260 } 261 /* END_CASE */