Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 1 | /* |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 2 | * Test driver for generating and verifying keys. |
| 3 | * Currently only supports generating and verifying ECC keys. |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 4 | */ |
Steven Cooreman | 2c7b2f8 | 2020-09-02 13:43:46 +0200 | [diff] [blame] | 5 | /* Copyright The Mbed TLS Contributors |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 6 | * SPDX-License-Identifier: Apache-2.0 |
| 7 | * |
| 8 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 9 | * not use this file except in compliance with the License. |
| 10 | * You may obtain a copy of the License at |
| 11 | * |
| 12 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 13 | * |
| 14 | * Unless required by applicable law or agreed to in writing, software |
| 15 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 16 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 17 | * See the License for the specific language governing permissions and |
| 18 | * limitations under the License. |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 19 | */ |
| 20 | |
| 21 | #if !defined(MBEDTLS_CONFIG_FILE) |
| 22 | #include "mbedtls/config.h" |
| 23 | #else |
| 24 | #include MBEDTLS_CONFIG_FILE |
| 25 | #endif |
| 26 | |
Steven Cooreman | f1720ea | 2020-07-24 18:41:58 +0200 | [diff] [blame] | 27 | #if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST) |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 28 | #include "psa/crypto.h" |
Steven Cooreman | 15f58d2 | 2020-09-04 13:05:23 +0200 | [diff] [blame] | 29 | #include "psa_crypto_core.h" |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 30 | #include "psa_crypto_ecp.h" |
| 31 | #include "psa_crypto_rsa.h" |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 32 | #include "mbedtls/ecp.h" |
| 33 | #include "mbedtls/error.h" |
| 34 | |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 35 | #include "test/drivers/key_management.h" |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 36 | |
| 37 | #include "test/random.h" |
| 38 | |
| 39 | #include <string.h> |
| 40 | |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 41 | test_driver_key_management_hooks_t test_driver_key_management_hooks = |
| 42 | TEST_DRIVER_KEY_MANAGEMENT_INIT; |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 43 | |
| 44 | psa_status_t test_transparent_generate_key( |
| 45 | const psa_key_attributes_t *attributes, |
| 46 | uint8_t *key, size_t key_size, size_t *key_length ) |
| 47 | { |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 48 | ++test_driver_key_management_hooks.hits; |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 49 | |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 50 | if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS ) |
| 51 | return( test_driver_key_management_hooks.forced_status ); |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 52 | |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 53 | if( test_driver_key_management_hooks.forced_output != NULL ) |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 54 | { |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 55 | if( test_driver_key_management_hooks.forced_output_length > key_size ) |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 56 | return( PSA_ERROR_BUFFER_TOO_SMALL ); |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 57 | memcpy( key, test_driver_key_management_hooks.forced_output, |
| 58 | test_driver_key_management_hooks.forced_output_length ); |
| 59 | *key_length = test_driver_key_management_hooks.forced_output_length; |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 60 | return( PSA_SUCCESS ); |
| 61 | } |
| 62 | |
| 63 | /* Copied from psa_crypto.c */ |
John Durkop | 6ba40d1 | 2020-11-10 08:50:04 -0800 | [diff] [blame] | 64 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \ |
| 65 | defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY) |
Steven Cooreman | 56250fd | 2020-09-04 13:07:15 +0200 | [diff] [blame] | 66 | if ( PSA_KEY_TYPE_IS_ECC( psa_get_key_type( attributes ) ) |
| 67 | && PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) ) |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 68 | { |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 69 | psa_ecc_family_t curve = PSA_KEY_TYPE_ECC_GET_FAMILY( |
| 70 | psa_get_key_type( attributes ) ); |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 71 | mbedtls_ecp_group_id grp_id = |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 72 | mbedtls_ecc_group_of_psa( |
| 73 | curve, |
Gilles Peskine | 2fa6b5f | 2021-01-27 15:44:45 +0100 | [diff] [blame] | 74 | psa_get_key_bits( attributes ), 0 ); |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 75 | const mbedtls_ecp_curve_info *curve_info = |
| 76 | mbedtls_ecp_curve_info_from_grp_id( grp_id ); |
| 77 | mbedtls_ecp_keypair ecp; |
| 78 | mbedtls_test_rnd_pseudo_info rnd_info; |
| 79 | memset( &rnd_info, 0x5A, sizeof( mbedtls_test_rnd_pseudo_info ) ); |
| 80 | |
| 81 | int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED; |
| 82 | if( attributes->domain_parameters_size != 0 ) |
| 83 | return( PSA_ERROR_NOT_SUPPORTED ); |
| 84 | if( grp_id == MBEDTLS_ECP_DP_NONE || curve_info == NULL ) |
| 85 | return( PSA_ERROR_NOT_SUPPORTED ); |
Steven Cooreman | 56250fd | 2020-09-04 13:07:15 +0200 | [diff] [blame] | 86 | if( curve_info->bit_size != psa_get_key_bits( attributes ) ) |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 87 | return( PSA_ERROR_INVALID_ARGUMENT ); |
| 88 | mbedtls_ecp_keypair_init( &ecp ); |
| 89 | ret = mbedtls_ecp_gen_key( grp_id, &ecp, |
| 90 | &mbedtls_test_rnd_pseudo_rand, |
| 91 | &rnd_info ); |
| 92 | if( ret != 0 ) |
| 93 | { |
| 94 | mbedtls_ecp_keypair_free( &ecp ); |
| 95 | return( mbedtls_to_psa_error( ret ) ); |
| 96 | } |
| 97 | |
| 98 | /* Make sure to use export representation */ |
Steven Cooreman | 56250fd | 2020-09-04 13:07:15 +0200 | [diff] [blame] | 99 | size_t bytes = PSA_BITS_TO_BYTES( psa_get_key_bits( attributes ) ); |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 100 | if( key_size < bytes ) |
| 101 | { |
| 102 | mbedtls_ecp_keypair_free( &ecp ); |
| 103 | return( PSA_ERROR_BUFFER_TOO_SMALL ); |
| 104 | } |
| 105 | psa_status_t status = mbedtls_to_psa_error( |
| 106 | mbedtls_mpi_write_binary( &ecp.d, key, bytes ) ); |
| 107 | |
| 108 | if( status == PSA_SUCCESS ) |
| 109 | { |
| 110 | *key_length = bytes; |
| 111 | } |
Steven Cooreman | 40120f6 | 2020-10-29 11:42:22 +0100 | [diff] [blame] | 112 | else |
| 113 | { |
| 114 | memset( key, 0, bytes ); |
| 115 | } |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 116 | |
| 117 | mbedtls_ecp_keypair_free( &ecp ); |
| 118 | return( status ); |
| 119 | } |
| 120 | else |
John Durkop | 6ba40d1 | 2020-11-10 08:50:04 -0800 | [diff] [blame] | 121 | #endif /* MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR || |
| 122 | * MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY */ |
Ronald Cron | 3a9c46b | 2020-11-06 09:38:35 +0100 | [diff] [blame^] | 123 | |
| 124 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) |
| 125 | if ( psa_get_key_type( attributes ) == PSA_KEY_TYPE_RSA_KEY_PAIR ) |
| 126 | return( mbedtls_transparent_test_driver_rsa_generate_key( |
| 127 | attributes, key, key_size, key_length ) ); |
| 128 | else |
| 129 | #endif /* defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) */ |
| 130 | { |
| 131 | (void)attributes; |
| 132 | return( PSA_ERROR_NOT_SUPPORTED ); |
| 133 | } |
Steven Cooreman | 2a1664c | 2020-07-20 15:33:08 +0200 | [diff] [blame] | 134 | } |
| 135 | |
| 136 | psa_status_t test_opaque_generate_key( |
| 137 | const psa_key_attributes_t *attributes, |
| 138 | uint8_t *key, size_t key_size, size_t *key_length ) |
| 139 | { |
| 140 | (void) attributes; |
| 141 | (void) key; |
| 142 | (void) key_size; |
| 143 | (void) key_length; |
| 144 | return( PSA_ERROR_NOT_SUPPORTED ); |
| 145 | } |
| 146 | |
Ronald Cron | 8328287 | 2020-11-22 14:02:39 +0100 | [diff] [blame] | 147 | psa_status_t test_transparent_import_key( |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 148 | const psa_key_attributes_t *attributes, |
| 149 | const uint8_t *data, |
| 150 | size_t data_length, |
Ronald Cron | 8328287 | 2020-11-22 14:02:39 +0100 | [diff] [blame] | 151 | uint8_t *key_buffer, |
| 152 | size_t key_buffer_size, |
| 153 | size_t *key_buffer_length, |
| 154 | size_t *bits) |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 155 | { |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 156 | ++test_driver_key_management_hooks.hits; |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 157 | |
Steven Cooreman | c4813a6 | 2020-10-23 11:45:43 +0200 | [diff] [blame] | 158 | if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS ) |
| 159 | return( test_driver_key_management_hooks.forced_status ); |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 160 | |
Ronald Cron | 784fb32 | 2020-11-30 13:55:05 +0100 | [diff] [blame] | 161 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
| 162 | psa_key_type_t type = psa_get_key_type( attributes ); |
| 163 | |
John Durkop | 6ba40d1 | 2020-11-10 08:50:04 -0800 | [diff] [blame] | 164 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \ |
| 165 | defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY) |
Ronald Cron | 784fb32 | 2020-11-30 13:55:05 +0100 | [diff] [blame] | 166 | if( PSA_KEY_TYPE_IS_ECC( type ) ) |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 167 | { |
Ronald Cron | 784fb32 | 2020-11-30 13:55:05 +0100 | [diff] [blame] | 168 | status = mbedtls_transparent_test_driver_ecp_import_key( |
| 169 | attributes, |
| 170 | data, data_length, |
| 171 | key_buffer, key_buffer_size, |
| 172 | key_buffer_length, bits ); |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 173 | } |
Ronald Cron | 784fb32 | 2020-11-30 13:55:05 +0100 | [diff] [blame] | 174 | else |
| 175 | #endif |
| 176 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \ |
| 177 | defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY) |
| 178 | if( PSA_KEY_TYPE_IS_RSA( type ) ) |
| 179 | { |
| 180 | status = mbedtls_transparent_test_driver_rsa_import_key( |
| 181 | attributes, |
| 182 | data, data_length, |
| 183 | key_buffer, key_buffer_size, |
| 184 | key_buffer_length, bits ); |
| 185 | } |
| 186 | else |
| 187 | #endif |
| 188 | { |
| 189 | status = PSA_ERROR_NOT_SUPPORTED; |
| 190 | (void)data; |
| 191 | (void)data_length; |
| 192 | (void)key_buffer; |
| 193 | (void)key_buffer_size; |
| 194 | (void)key_buffer_length; |
| 195 | (void)bits; |
| 196 | (void)type; |
| 197 | } |
| 198 | |
| 199 | return( status ); |
Steven Cooreman | 0452476 | 2020-10-13 17:43:44 +0200 | [diff] [blame] | 200 | } |
| 201 | |
Ronald Cron | 6722798 | 2020-11-26 15:16:05 +0100 | [diff] [blame] | 202 | psa_status_t test_opaque_export_key( |
| 203 | const psa_key_attributes_t *attributes, |
| 204 | const uint8_t *key, size_t key_length, |
| 205 | uint8_t *data, size_t data_size, size_t *data_length ) |
| 206 | { |
| 207 | (void) attributes; |
| 208 | (void) key; |
| 209 | (void) key_length; |
| 210 | (void) data; |
| 211 | (void) data_size; |
| 212 | (void) data_length; |
| 213 | return( PSA_ERROR_NOT_SUPPORTED ); |
| 214 | } |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 215 | |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 216 | psa_status_t test_transparent_export_public_key( |
| 217 | const psa_key_attributes_t *attributes, |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 218 | const uint8_t *key_buffer, size_t key_buffer_size, |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 219 | uint8_t *data, size_t data_size, size_t *data_length ) |
| 220 | { |
Gilles Peskine | c240236 | 2020-11-22 18:47:43 +0100 | [diff] [blame] | 221 | ++test_driver_key_management_hooks.hits; |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 222 | |
Gilles Peskine | c240236 | 2020-11-22 18:47:43 +0100 | [diff] [blame] | 223 | if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS ) |
| 224 | return( test_driver_key_management_hooks.forced_status ); |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 225 | |
Gilles Peskine | c240236 | 2020-11-22 18:47:43 +0100 | [diff] [blame] | 226 | if( test_driver_key_management_hooks.forced_output != NULL ) |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 227 | { |
Gilles Peskine | c240236 | 2020-11-22 18:47:43 +0100 | [diff] [blame] | 228 | if( test_driver_key_management_hooks.forced_output_length > data_size ) |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 229 | return( PSA_ERROR_BUFFER_TOO_SMALL ); |
Gilles Peskine | c240236 | 2020-11-22 18:47:43 +0100 | [diff] [blame] | 230 | memcpy( data, test_driver_key_management_hooks.forced_output, |
| 231 | test_driver_key_management_hooks.forced_output_length ); |
| 232 | *data_length = test_driver_key_management_hooks.forced_output_length; |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 233 | return( PSA_SUCCESS ); |
| 234 | } |
| 235 | |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 236 | psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; |
| 237 | psa_key_type_t key_type = psa_get_key_type( attributes ); |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 238 | |
| 239 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \ |
| 240 | defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY) |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 241 | if( PSA_KEY_TYPE_IS_ECC( key_type ) ) |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 242 | { |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 243 | status = mbedtls_transparent_test_driver_ecp_export_public_key( |
| 244 | attributes, |
| 245 | key_buffer, key_buffer_size, |
| 246 | data, data_size, data_length ); |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 247 | } |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 248 | else |
| 249 | #endif |
| 250 | #if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_KEY_PAIR) || \ |
| 251 | defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_RSA_PUBLIC_KEY) |
| 252 | if( PSA_KEY_TYPE_IS_RSA( key_type ) ) |
| 253 | { |
| 254 | status = mbedtls_transparent_test_driver_rsa_export_public_key( |
| 255 | attributes, |
| 256 | key_buffer, key_buffer_size, |
| 257 | data, data_size, data_length ); |
| 258 | } |
| 259 | else |
| 260 | #endif |
| 261 | { |
| 262 | status = PSA_ERROR_NOT_SUPPORTED; |
| 263 | (void)key_buffer; |
| 264 | (void)key_buffer_size; |
| 265 | (void)key_type; |
| 266 | } |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 267 | |
Ronald Cron | f1057d3 | 2020-11-26 19:19:10 +0100 | [diff] [blame] | 268 | return( status ); |
Steven Cooreman | b9b8442 | 2020-10-14 14:39:20 +0200 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | psa_status_t test_opaque_export_public_key( |
| 272 | const psa_key_attributes_t *attributes, |
| 273 | const uint8_t *key, size_t key_length, |
| 274 | uint8_t *data, size_t data_size, size_t *data_length ) |
| 275 | { |
| 276 | (void) attributes; |
| 277 | (void) key; |
| 278 | (void) key_length; |
| 279 | (void) data; |
| 280 | (void) data_size; |
| 281 | (void) data_length; |
| 282 | return( PSA_ERROR_NOT_SUPPORTED ); |
| 283 | } |
| 284 | |
Steven Cooreman | f1720ea | 2020-07-24 18:41:58 +0200 | [diff] [blame] | 285 | #endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */ |