blob: 46af648f8c10f5528166016af0fd49ea10b4131f [file] [log] [blame]
Steven Cooreman2a1664c2020-07-20 15:33:08 +02001/*
Steven Cooreman04524762020-10-13 17:43:44 +02002 * Test driver for generating and verifying keys.
3 * Currently only supports generating and verifying ECC keys.
Steven Cooreman2a1664c2020-07-20 15:33:08 +02004 */
Steven Cooreman2c7b2f82020-09-02 13:43:46 +02005/* Copyright The Mbed TLS Contributors
Steven Cooreman2a1664c2020-07-20 15:33:08 +02006 * 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 Cooreman2a1664c2020-07-20 15:33:08 +020019 */
20
21#if !defined(MBEDTLS_CONFIG_FILE)
22#include "mbedtls/config.h"
23#else
24#include MBEDTLS_CONFIG_FILE
25#endif
26
Steven Cooremanf1720ea2020-07-24 18:41:58 +020027#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST)
Steven Cooreman2a1664c2020-07-20 15:33:08 +020028#include "psa/crypto.h"
Steven Cooreman15f58d22020-09-04 13:05:23 +020029#include "psa_crypto_core.h"
Ronald Cronf1057d32020-11-26 19:19:10 +010030#include "psa_crypto_ecp.h"
31#include "psa_crypto_rsa.h"
Steven Cooreman2a1664c2020-07-20 15:33:08 +020032#include "mbedtls/ecp.h"
33#include "mbedtls/error.h"
34
Steven Cooremanc4813a62020-10-23 11:45:43 +020035#include "test/drivers/key_management.h"
Steven Cooreman2a1664c2020-07-20 15:33:08 +020036
37#include "test/random.h"
38
39#include <string.h>
40
Steven Cooremanc4813a62020-10-23 11:45:43 +020041test_driver_key_management_hooks_t test_driver_key_management_hooks =
42 TEST_DRIVER_KEY_MANAGEMENT_INIT;
Steven Cooreman2a1664c2020-07-20 15:33:08 +020043
44psa_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 Cooremanc4813a62020-10-23 11:45:43 +020048 ++test_driver_key_management_hooks.hits;
Steven Cooreman2a1664c2020-07-20 15:33:08 +020049
Steven Cooremanc4813a62020-10-23 11:45:43 +020050 if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
51 return( test_driver_key_management_hooks.forced_status );
Steven Cooreman2a1664c2020-07-20 15:33:08 +020052
Steven Cooremanc4813a62020-10-23 11:45:43 +020053 if( test_driver_key_management_hooks.forced_output != NULL )
Steven Cooreman2a1664c2020-07-20 15:33:08 +020054 {
Steven Cooremanc4813a62020-10-23 11:45:43 +020055 if( test_driver_key_management_hooks.forced_output_length > key_size )
Steven Cooreman2a1664c2020-07-20 15:33:08 +020056 return( PSA_ERROR_BUFFER_TOO_SMALL );
Steven Cooremanc4813a62020-10-23 11:45:43 +020057 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 Cooreman2a1664c2020-07-20 15:33:08 +020060 return( PSA_SUCCESS );
61 }
62
63 /* Copied from psa_crypto.c */
John Durkop6ba40d12020-11-10 08:50:04 -080064#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
65 defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
Steven Cooreman56250fd2020-09-04 13:07:15 +020066 if ( PSA_KEY_TYPE_IS_ECC( psa_get_key_type( attributes ) )
67 && PSA_KEY_TYPE_IS_KEY_PAIR( psa_get_key_type( attributes ) ) )
Steven Cooreman2a1664c2020-07-20 15:33:08 +020068 {
Steven Cooremanc4813a62020-10-23 11:45:43 +020069 psa_ecc_family_t curve = PSA_KEY_TYPE_ECC_GET_FAMILY(
70 psa_get_key_type( attributes ) );
Steven Cooreman2a1664c2020-07-20 15:33:08 +020071 mbedtls_ecp_group_id grp_id =
Steven Cooremanc4813a62020-10-23 11:45:43 +020072 mbedtls_ecc_group_of_psa(
73 curve,
Gilles Peskine2fa6b5f2021-01-27 15:44:45 +010074 psa_get_key_bits( attributes ), 0 );
Steven Cooreman2a1664c2020-07-20 15:33:08 +020075 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 Cooreman56250fd2020-09-04 13:07:15 +020086 if( curve_info->bit_size != psa_get_key_bits( attributes ) )
Steven Cooreman2a1664c2020-07-20 15:33:08 +020087 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 Cooreman56250fd2020-09-04 13:07:15 +020099 size_t bytes = PSA_BITS_TO_BYTES( psa_get_key_bits( attributes ) );
Steven Cooreman2a1664c2020-07-20 15:33:08 +0200100 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 Cooreman40120f62020-10-29 11:42:22 +0100112 else
113 {
114 memset( key, 0, bytes );
115 }
Steven Cooreman2a1664c2020-07-20 15:33:08 +0200116
117 mbedtls_ecp_keypair_free( &ecp );
118 return( status );
119 }
120 else
John Durkop6ba40d12020-11-10 08:50:04 -0800121#endif /* MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR ||
122 * MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY */
Ronald Cron3a9c46b2020-11-06 09:38:35 +0100123
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 Cooreman2a1664c2020-07-20 15:33:08 +0200134}
135
136psa_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 Cron83282872020-11-22 14:02:39 +0100147psa_status_t test_transparent_import_key(
Steven Cooremanb9b84422020-10-14 14:39:20 +0200148 const psa_key_attributes_t *attributes,
149 const uint8_t *data,
150 size_t data_length,
Ronald Cron83282872020-11-22 14:02:39 +0100151 uint8_t *key_buffer,
152 size_t key_buffer_size,
153 size_t *key_buffer_length,
154 size_t *bits)
Steven Cooreman04524762020-10-13 17:43:44 +0200155{
Steven Cooremanc4813a62020-10-23 11:45:43 +0200156 ++test_driver_key_management_hooks.hits;
Steven Cooreman04524762020-10-13 17:43:44 +0200157
Steven Cooremanc4813a62020-10-23 11:45:43 +0200158 if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
159 return( test_driver_key_management_hooks.forced_status );
Steven Cooreman04524762020-10-13 17:43:44 +0200160
Ronald Cron784fb322020-11-30 13:55:05 +0100161 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
162 psa_key_type_t type = psa_get_key_type( attributes );
163
John Durkop6ba40d12020-11-10 08:50:04 -0800164#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
165 defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
Ronald Cron784fb322020-11-30 13:55:05 +0100166 if( PSA_KEY_TYPE_IS_ECC( type ) )
Steven Cooreman04524762020-10-13 17:43:44 +0200167 {
Ronald Cron784fb322020-11-30 13:55:05 +0100168 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 Cooreman04524762020-10-13 17:43:44 +0200173 }
Ronald Cron784fb322020-11-30 13:55:05 +0100174 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 Cooreman04524762020-10-13 17:43:44 +0200200}
201
Ronald Cron67227982020-11-26 15:16:05 +0100202psa_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 Cronf1057d32020-11-26 19:19:10 +0100215
Steven Cooremanb9b84422020-10-14 14:39:20 +0200216psa_status_t test_transparent_export_public_key(
217 const psa_key_attributes_t *attributes,
Ronald Cronf1057d32020-11-26 19:19:10 +0100218 const uint8_t *key_buffer, size_t key_buffer_size,
Steven Cooremanb9b84422020-10-14 14:39:20 +0200219 uint8_t *data, size_t data_size, size_t *data_length )
220{
Gilles Peskinec2402362020-11-22 18:47:43 +0100221 ++test_driver_key_management_hooks.hits;
Steven Cooremanb9b84422020-10-14 14:39:20 +0200222
Gilles Peskinec2402362020-11-22 18:47:43 +0100223 if( test_driver_key_management_hooks.forced_status != PSA_SUCCESS )
224 return( test_driver_key_management_hooks.forced_status );
Steven Cooremanb9b84422020-10-14 14:39:20 +0200225
Gilles Peskinec2402362020-11-22 18:47:43 +0100226 if( test_driver_key_management_hooks.forced_output != NULL )
Steven Cooremanb9b84422020-10-14 14:39:20 +0200227 {
Gilles Peskinec2402362020-11-22 18:47:43 +0100228 if( test_driver_key_management_hooks.forced_output_length > data_size )
Steven Cooremanb9b84422020-10-14 14:39:20 +0200229 return( PSA_ERROR_BUFFER_TOO_SMALL );
Gilles Peskinec2402362020-11-22 18:47:43 +0100230 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 Cooremanb9b84422020-10-14 14:39:20 +0200233 return( PSA_SUCCESS );
234 }
235
Ronald Cronf1057d32020-11-26 19:19:10 +0100236 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
237 psa_key_type_t key_type = psa_get_key_type( attributes );
Steven Cooremanb9b84422020-10-14 14:39:20 +0200238
239#if defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_KEY_PAIR) || \
240 defined(MBEDTLS_PSA_ACCEL_KEY_TYPE_ECC_PUBLIC_KEY)
Ronald Cronf1057d32020-11-26 19:19:10 +0100241 if( PSA_KEY_TYPE_IS_ECC( key_type ) )
Steven Cooremanb9b84422020-10-14 14:39:20 +0200242 {
Ronald Cronf1057d32020-11-26 19:19:10 +0100243 status = mbedtls_transparent_test_driver_ecp_export_public_key(
244 attributes,
245 key_buffer, key_buffer_size,
246 data, data_size, data_length );
Steven Cooremanb9b84422020-10-14 14:39:20 +0200247 }
Ronald Cronf1057d32020-11-26 19:19:10 +0100248 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 Cooremanb9b84422020-10-14 14:39:20 +0200267
Ronald Cronf1057d32020-11-26 19:19:10 +0100268 return( status );
Steven Cooremanb9b84422020-10-14 14:39:20 +0200269}
270
271psa_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 Cooremanf1720ea2020-07-24 18:41:58 +0200285#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */