test_driver_signature.c (13760B)
1 /* 2 * Test driver for signature functions. 3 * Currently supports signing and verifying precalculated hashes, using 4 * only deterministic ECDSA on curves secp256r1, secp384r1 and secp521r1. 5 */ 6 /* Copyright The Mbed TLS Contributors 7 * SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 8 */ 9 10 #include <test/helpers.h> 11 12 #if defined(PSA_CRYPTO_DRIVER_TEST) 13 #include "psa/crypto.h" 14 #include "psa_crypto_core.h" 15 #include "psa_crypto_ecp.h" 16 #include "psa_crypto_hash.h" 17 #include "psa_crypto_rsa.h" 18 #include "mbedtls/ecp.h" 19 20 #include "test/drivers/hash.h" 21 #include "test/drivers/signature.h" 22 #include "test/drivers/hash.h" 23 24 #include "mbedtls/ecdsa.h" 25 26 #include "test/random.h" 27 28 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) 29 #if MBEDTLS_VERSION_MAJOR < 4 30 #include "libtestdriver1/library/psa_crypto_ecp.h" 31 #include "libtestdriver1/library/psa_crypto_hash.h" 32 #include "libtestdriver1/library/psa_crypto_rsa.h" 33 #else 34 #include "libtestdriver1/tf-psa-crypto/drivers/builtin/src/psa_crypto_ecp.h" 35 #include "libtestdriver1/tf-psa-crypto/drivers/builtin/src/psa_crypto_hash.h" 36 #include "libtestdriver1/tf-psa-crypto/drivers/builtin/src/psa_crypto_rsa.h" 37 #endif 38 #endif 39 40 #include <string.h> 41 42 mbedtls_test_driver_signature_hooks_t 43 mbedtls_test_driver_signature_sign_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT; 44 mbedtls_test_driver_signature_hooks_t 45 mbedtls_test_driver_signature_verify_hooks = MBEDTLS_TEST_DRIVER_SIGNATURE_INIT; 46 47 psa_status_t sign_hash( 48 const psa_key_attributes_t *attributes, 49 const uint8_t *key_buffer, 50 size_t key_buffer_size, 51 psa_algorithm_t alg, 52 const uint8_t *hash, 53 size_t hash_length, 54 uint8_t *signature, 55 size_t signature_size, 56 size_t *signature_length) 57 { 58 if (attributes->type == PSA_KEY_TYPE_RSA_KEY_PAIR) { 59 if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || 60 PSA_ALG_IS_RSA_PSS(alg)) { 61 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 62 (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \ 63 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)) 64 return libtestdriver1_mbedtls_psa_rsa_sign_hash( 65 (const libtestdriver1_psa_key_attributes_t *) attributes, 66 key_buffer, key_buffer_size, 67 alg, hash, hash_length, 68 signature, signature_size, signature_length); 69 #elif defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \ 70 defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) 71 return mbedtls_psa_rsa_sign_hash( 72 attributes, 73 key_buffer, key_buffer_size, 74 alg, hash, hash_length, 75 signature, signature_size, signature_length); 76 #endif 77 } else { 78 return PSA_ERROR_INVALID_ARGUMENT; 79 } 80 } else if (PSA_KEY_TYPE_IS_ECC(attributes->type)) { 81 if (PSA_ALG_IS_ECDSA(alg)) { 82 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 83 (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \ 84 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)) 85 return libtestdriver1_mbedtls_psa_ecdsa_sign_hash( 86 (const libtestdriver1_psa_key_attributes_t *) attributes, 87 key_buffer, key_buffer_size, 88 alg, hash, hash_length, 89 signature, signature_size, signature_length); 90 #elif defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \ 91 defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA) 92 return mbedtls_psa_ecdsa_sign_hash( 93 attributes, 94 key_buffer, key_buffer_size, 95 alg, hash, hash_length, 96 signature, signature_size, signature_length); 97 #endif 98 } else { 99 return PSA_ERROR_INVALID_ARGUMENT; 100 } 101 } 102 103 (void) attributes; 104 (void) key_buffer; 105 (void) key_buffer_size; 106 (void) alg; 107 (void) hash; 108 (void) hash_length; 109 (void) signature; 110 (void) signature_size; 111 (void) signature_length; 112 return PSA_ERROR_NOT_SUPPORTED; 113 } 114 115 psa_status_t verify_hash( 116 const psa_key_attributes_t *attributes, 117 const uint8_t *key_buffer, 118 size_t key_buffer_size, 119 psa_algorithm_t alg, 120 const uint8_t *hash, 121 size_t hash_length, 122 const uint8_t *signature, 123 size_t signature_length) 124 { 125 if (PSA_KEY_TYPE_IS_RSA(attributes->type)) { 126 if (PSA_ALG_IS_RSA_PKCS1V15_SIGN(alg) || 127 PSA_ALG_IS_RSA_PSS(alg)) { 128 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 129 (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \ 130 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS)) 131 return libtestdriver1_mbedtls_psa_rsa_verify_hash( 132 (const libtestdriver1_psa_key_attributes_t *) attributes, 133 key_buffer, key_buffer_size, 134 alg, hash, hash_length, 135 signature, signature_length); 136 #elif defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \ 137 defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) 138 return mbedtls_psa_rsa_verify_hash( 139 attributes, 140 key_buffer, key_buffer_size, 141 alg, hash, hash_length, 142 signature, signature_length); 143 #endif 144 } else { 145 return PSA_ERROR_INVALID_ARGUMENT; 146 } 147 } else if (PSA_KEY_TYPE_IS_ECC(attributes->type)) { 148 if (PSA_ALG_IS_ECDSA(alg)) { 149 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 150 (defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \ 151 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)) 152 return libtestdriver1_mbedtls_psa_ecdsa_verify_hash( 153 (const libtestdriver1_psa_key_attributes_t *) attributes, 154 key_buffer, key_buffer_size, 155 alg, hash, hash_length, 156 signature, signature_length); 157 #elif defined(MBEDTLS_PSA_BUILTIN_ALG_ECDSA) || \ 158 defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA) 159 return mbedtls_psa_ecdsa_verify_hash( 160 attributes, 161 key_buffer, key_buffer_size, 162 alg, hash, hash_length, 163 signature, signature_length); 164 #endif 165 } else { 166 return PSA_ERROR_INVALID_ARGUMENT; 167 } 168 } 169 170 (void) attributes; 171 (void) key_buffer; 172 (void) key_buffer_size; 173 (void) alg; 174 (void) hash; 175 (void) hash_length; 176 (void) signature; 177 (void) signature_length; 178 return PSA_ERROR_NOT_SUPPORTED; 179 } 180 181 psa_status_t mbedtls_test_transparent_signature_sign_message( 182 const psa_key_attributes_t *attributes, 183 const uint8_t *key_buffer, 184 size_t key_buffer_size, 185 psa_algorithm_t alg, 186 const uint8_t *input, 187 size_t input_length, 188 uint8_t *signature, 189 size_t signature_size, 190 size_t *signature_length) 191 { 192 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; 193 size_t hash_length; 194 uint8_t hash[PSA_HASH_MAX_SIZE]; 195 196 ++mbedtls_test_driver_signature_sign_hooks.hits; 197 198 if (mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS) { 199 return mbedtls_test_driver_signature_sign_hooks.forced_status; 200 } 201 202 if (mbedtls_test_driver_signature_sign_hooks.forced_output != NULL) { 203 if (mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size) { 204 return PSA_ERROR_BUFFER_TOO_SMALL; 205 } 206 207 memcpy(signature, mbedtls_test_driver_signature_sign_hooks.forced_output, 208 mbedtls_test_driver_signature_sign_hooks.forced_output_length); 209 *signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length; 210 211 return PSA_SUCCESS; 212 } 213 214 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 215 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH) 216 status = libtestdriver1_mbedtls_psa_hash_compute( 217 PSA_ALG_SIGN_GET_HASH(alg), input, input_length, 218 hash, sizeof(hash), &hash_length); 219 #elif defined(MBEDTLS_PSA_BUILTIN_HASH) 220 status = mbedtls_psa_hash_compute( 221 PSA_ALG_SIGN_GET_HASH(alg), input, input_length, 222 hash, sizeof(hash), &hash_length); 223 #else 224 (void) input; 225 (void) input_length; 226 status = PSA_ERROR_NOT_SUPPORTED; 227 #endif 228 if (status != PSA_SUCCESS) { 229 return status; 230 } 231 232 return sign_hash(attributes, key_buffer, key_buffer_size, 233 alg, hash, hash_length, 234 signature, signature_size, signature_length); 235 } 236 237 psa_status_t mbedtls_test_opaque_signature_sign_message( 238 const psa_key_attributes_t *attributes, 239 const uint8_t *key, 240 size_t key_length, 241 psa_algorithm_t alg, 242 const uint8_t *input, 243 size_t input_length, 244 uint8_t *signature, 245 size_t signature_size, 246 size_t *signature_length) 247 { 248 (void) attributes; 249 (void) key; 250 (void) key_length; 251 (void) alg; 252 (void) input; 253 (void) input_length; 254 (void) signature; 255 (void) signature_size; 256 (void) signature_length; 257 258 return PSA_ERROR_NOT_SUPPORTED; 259 } 260 261 psa_status_t mbedtls_test_transparent_signature_verify_message( 262 const psa_key_attributes_t *attributes, 263 const uint8_t *key_buffer, 264 size_t key_buffer_size, 265 psa_algorithm_t alg, 266 const uint8_t *input, 267 size_t input_length, 268 const uint8_t *signature, 269 size_t signature_length) 270 { 271 psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED; 272 size_t hash_length; 273 uint8_t hash[PSA_HASH_MAX_SIZE]; 274 275 ++mbedtls_test_driver_signature_verify_hooks.hits; 276 277 if (mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS) { 278 return mbedtls_test_driver_signature_verify_hooks.forced_status; 279 } 280 281 #if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ 282 defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_HASH) 283 status = libtestdriver1_mbedtls_psa_hash_compute( 284 PSA_ALG_SIGN_GET_HASH(alg), input, input_length, 285 hash, sizeof(hash), &hash_length); 286 #elif defined(MBEDTLS_PSA_BUILTIN_HASH) 287 status = mbedtls_psa_hash_compute( 288 PSA_ALG_SIGN_GET_HASH(alg), input, input_length, 289 hash, sizeof(hash), &hash_length); 290 #else 291 (void) input; 292 (void) input_length; 293 status = PSA_ERROR_NOT_SUPPORTED; 294 #endif 295 if (status != PSA_SUCCESS) { 296 return status; 297 } 298 299 return verify_hash(attributes, key_buffer, key_buffer_size, 300 alg, hash, hash_length, 301 signature, signature_length); 302 } 303 304 psa_status_t mbedtls_test_opaque_signature_verify_message( 305 const psa_key_attributes_t *attributes, 306 const uint8_t *key, 307 size_t key_length, 308 psa_algorithm_t alg, 309 const uint8_t *input, 310 size_t input_length, 311 const uint8_t *signature, 312 size_t signature_length) 313 { 314 (void) attributes; 315 (void) key; 316 (void) key_length; 317 (void) alg; 318 (void) input; 319 (void) input_length; 320 (void) signature; 321 (void) signature_length; 322 323 return PSA_ERROR_NOT_SUPPORTED; 324 } 325 326 psa_status_t mbedtls_test_transparent_signature_sign_hash( 327 const psa_key_attributes_t *attributes, 328 const uint8_t *key_buffer, size_t key_buffer_size, 329 psa_algorithm_t alg, 330 const uint8_t *hash, size_t hash_length, 331 uint8_t *signature, size_t signature_size, size_t *signature_length) 332 { 333 ++mbedtls_test_driver_signature_sign_hooks.hits; 334 335 if (mbedtls_test_driver_signature_sign_hooks.forced_status != PSA_SUCCESS) { 336 return mbedtls_test_driver_signature_sign_hooks.forced_status; 337 } 338 339 if (mbedtls_test_driver_signature_sign_hooks.forced_output != NULL) { 340 if (mbedtls_test_driver_signature_sign_hooks.forced_output_length > signature_size) { 341 return PSA_ERROR_BUFFER_TOO_SMALL; 342 } 343 memcpy(signature, mbedtls_test_driver_signature_sign_hooks.forced_output, 344 mbedtls_test_driver_signature_sign_hooks.forced_output_length); 345 *signature_length = mbedtls_test_driver_signature_sign_hooks.forced_output_length; 346 return PSA_SUCCESS; 347 } 348 349 return sign_hash(attributes, key_buffer, key_buffer_size, 350 alg, hash, hash_length, 351 signature, signature_size, signature_length); 352 } 353 354 psa_status_t mbedtls_test_opaque_signature_sign_hash( 355 const psa_key_attributes_t *attributes, 356 const uint8_t *key, size_t key_length, 357 psa_algorithm_t alg, 358 const uint8_t *hash, size_t hash_length, 359 uint8_t *signature, size_t signature_size, size_t *signature_length) 360 { 361 (void) attributes; 362 (void) key; 363 (void) key_length; 364 (void) alg; 365 (void) hash; 366 (void) hash_length; 367 (void) signature; 368 (void) signature_size; 369 (void) signature_length; 370 371 return PSA_ERROR_NOT_SUPPORTED; 372 } 373 374 psa_status_t mbedtls_test_transparent_signature_verify_hash( 375 const psa_key_attributes_t *attributes, 376 const uint8_t *key_buffer, size_t key_buffer_size, 377 psa_algorithm_t alg, 378 const uint8_t *hash, size_t hash_length, 379 const uint8_t *signature, size_t signature_length) 380 { 381 ++mbedtls_test_driver_signature_verify_hooks.hits; 382 383 if (mbedtls_test_driver_signature_verify_hooks.forced_status != PSA_SUCCESS) { 384 return mbedtls_test_driver_signature_verify_hooks.forced_status; 385 } 386 387 return verify_hash(attributes, key_buffer, key_buffer_size, 388 alg, hash, hash_length, 389 signature, signature_length); 390 } 391 392 psa_status_t mbedtls_test_opaque_signature_verify_hash( 393 const psa_key_attributes_t *attributes, 394 const uint8_t *key, size_t key_length, 395 psa_algorithm_t alg, 396 const uint8_t *hash, size_t hash_length, 397 const uint8_t *signature, size_t signature_length) 398 { 399 (void) attributes; 400 (void) key; 401 (void) key_length; 402 (void) alg; 403 (void) hash; 404 (void) hash_length; 405 (void) signature; 406 (void) signature_length; 407 return PSA_ERROR_NOT_SUPPORTED; 408 } 409 410 #endif /* PSA_CRYPTO_DRIVER_TEST */