From d3da040f34c0a0107e30edc372804768ff7284dd Mon Sep 17 00:00:00 2001 From: Przemek Stekiel Date: Tue, 22 Nov 2022 13:53:26 +0100 Subject: [PATCH] Add test driver impl for pake Signed-off-by: Przemek Stekiel --- tests/include/test/drivers/pake.h | 140 +++++++++ tests/src/drivers/test_driver_pake.c | 428 +++++++++++++++++++++++++++ 2 files changed, 568 insertions(+) create mode 100644 tests/include/test/drivers/pake.h create mode 100644 tests/src/drivers/test_driver_pake.c diff --git a/tests/include/test/drivers/pake.h b/tests/include/test/drivers/pake.h new file mode 100644 index 0000000000..81e87113b5 --- /dev/null +++ b/tests/include/test/drivers/pake.h @@ -0,0 +1,140 @@ +/* + * Test driver for PAKE driver entry points. + */ +/* Copyright The Mbed TLS Contributors + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PSA_CRYPTO_TEST_DRIVERS_PAKE_H +#define PSA_CRYPTO_TEST_DRIVERS_PAKE_H + +#include "mbedtls/build_info.h" + +#if defined(PSA_CRYPTO_DRIVER_TEST) +#include + +typedef struct { + /* If not PSA_SUCCESS, return this error code instead of processing the + * function call. */ + psa_status_t forced_status; + /* Count the amount of times PAKE driver functions are called. */ + unsigned long hits; + /* Status returned by the last PAKE driver function call. */ + psa_status_t driver_status; + /* Output returned by pake_output */ + void *forced_output; + size_t forced_output_length; +} mbedtls_test_driver_pake_hooks_t; + +#define MBEDTLS_TEST_DRIVER_PAKE_INIT { 0, 0, 0, NULL, 0 } +static inline mbedtls_test_driver_pake_hooks_t +mbedtls_test_driver_pake_hooks_init(void) +{ + const mbedtls_test_driver_pake_hooks_t v = MBEDTLS_TEST_DRIVER_PAKE_INIT; + return v; +} + +extern mbedtls_test_driver_pake_hooks_t mbedtls_test_driver_pake_hooks; + +psa_status_t mbedtls_test_transparent_pake_setup( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const psa_pake_cipher_suite_t *cipher_suite); + +psa_status_t mbedtls_test_transparent_set_password_key( + const psa_key_attributes_t *attributes, + mbedtls_transparent_test_driver_pake_operation_t *operation, + uint8_t *key_buffer, + size_t key_size); + +psa_status_t mbedtls_test_transparent_pake_set_user( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const uint8_t *user_id, + size_t user_id_len); + +psa_status_t mbedtls_test_transparent_pake_set_peer( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const uint8_t *peer_id, + size_t peer_id_len); + +psa_status_t mbedtls_test_transparent_pake_set_role( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_role_t role); + +psa_status_t mbedtls_test_transparent_pake_output( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + uint8_t *output, + size_t output_size, + size_t *output_length); + +psa_status_t mbedtls_test_transparent_pake_input( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + const uint8_t *input, + size_t input_length); + +psa_status_t mbedtls_test_transparent_pake_get_implicit_key( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_key_derivation_operation_t *output); + +psa_status_t mbedtls_test_transparent_pake_abort( + mbedtls_transparent_test_driver_pake_operation_t *operation); + +psa_status_t mbedtls_test_opaque_pake_setup( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const psa_pake_cipher_suite_t *cipher_suite); + +psa_status_t mbedtls_test_opaque_set_password_key( + const psa_key_attributes_t *attributes, + mbedtls_opaque_test_driver_pake_operation_t *operation, + uint8_t *key_buffer, + size_t key_size); + +psa_status_t mbedtls_test_opaque_pake_set_user( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const uint8_t *user_id, + size_t user_id_len); + +psa_status_t mbedtls_test_opaque_pake_set_peer( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const uint8_t *peer_id, + size_t peer_id_len); + +psa_status_t mbedtls_test_opaque_pake_set_role( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_role_t role); + +psa_status_t mbedtls_test_opaque_pake_output( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + uint8_t *output, + size_t output_size, + size_t *output_length); + +psa_status_t mbedtls_test_opaque_pake_input( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + const uint8_t *input, + size_t input_length); + +psa_status_t mbedtls_test_opaque_pake_get_implicit_key( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_key_derivation_operation_t *output); + +psa_status_t mbedtls_test_opaque_pake_abort( + mbedtls_opaque_test_driver_pake_operation_t *operation); + +#endif /* PSA_CRYPTO_DRIVER_TEST */ +#endif /* PSA_CRYPTO_TEST_DRIVERS_PAKE_H */ diff --git a/tests/src/drivers/test_driver_pake.c b/tests/src/drivers/test_driver_pake.c new file mode 100644 index 0000000000..1ced55936b --- /dev/null +++ b/tests/src/drivers/test_driver_pake.c @@ -0,0 +1,428 @@ +/* + * Test driver for MAC entry points. + */ +/* Copyright The Mbed TLS Contributors + * SPDX-License-Identifier: Apache-2.0 + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may + * not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT + * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +#if defined(MBEDTLS_PSA_CRYPTO_DRIVERS) && defined(PSA_CRYPTO_DRIVER_TEST) +#include "psa_crypto_pake.h" + +#include "test/drivers/pake.h" +#include "string.h" + +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) +#include "libtestdriver1/library/psa_crypto_pake.h" +#endif + +mbedtls_test_driver_pake_hooks_t mbedtls_test_driver_pake_hooks = + MBEDTLS_TEST_DRIVER_PAKE_INIT; + + +psa_status_t mbedtls_test_transparent_pake_setup( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const psa_pake_cipher_suite_t *cipher_suite) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_setup( + operation, (const libtestdriver1_psa_pake_cipher_suite_t *) cipher_suite); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_setup( + operation, cipher_suite); +#else + (void) operation; + (void) cipher_suite; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_set_password_key( + const psa_key_attributes_t *attributes, + mbedtls_transparent_test_driver_pake_operation_t *operation, + uint8_t *key_buffer, + size_t key_size) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_set_password_key( + (const libtestdriver1_psa_key_attributes_t *) attributes, + operation, key_buffer, key_size); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_set_password_key( + attributes, operation, key_buffer, key_size); +#else + (void) operation; + (void) key_buffer, + (void) key_size; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_set_user( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const uint8_t *user_id, + size_t user_id_len) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_set_user( + operation, user_id, user_id_len); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_set_user( + operation, user_id, user_id_len); +#else + (void) operation; + (void) user_id; + (void) user_id_len; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + + +psa_status_t mbedtls_test_transparent_pake_set_peer( + mbedtls_transparent_test_driver_pake_operation_t *operation, + const uint8_t *peer_id, + size_t peer_id_len) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_set_peer( + operation, peer_id, peer_id_len); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_set_peer( + operation, peer_id, peer_id_len); +#else + (void) operation; + (void) peer_id; + (void) peer_id_len; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_set_role( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_role_t role) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_set_role( + operation, role); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_set_role( + operation, role); +#else + (void) operation; + (void) role; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_output( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + uint8_t *output, + size_t output_size, + size_t *output_length) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_output != NULL) { + if (output_size < mbedtls_test_driver_pake_hooks.forced_output_length) { + return PSA_ERROR_BUFFER_TOO_SMALL; + } + + memcpy(output, + mbedtls_test_driver_pake_hooks.forced_output, + mbedtls_test_driver_pake_hooks.forced_output_length); + *output_length = mbedtls_test_driver_pake_hooks.forced_output_length; + + return mbedtls_test_driver_pake_hooks.forced_status; + } + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_output( + operation, step, output, output_size, output_length); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_output( + operation, step, output, output_size, output_length); +#else + (void) operation; + (void) step; + (void) output; + (void) output_size; + (void) output_length; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_input( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + const uint8_t *input, + size_t input_length) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_input( + operation, step, input, input_length); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_input( + operation, step, input, input_length); +#else + (void) operation; + (void) step; + (void) input; + (void) input_length; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_get_implicit_key( + mbedtls_transparent_test_driver_pake_operation_t *operation, + psa_key_derivation_operation_t *output) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_get_implicit_key( + operation, (libtestdriver1_psa_key_derivation_operation_t *) output); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_get_implicit_key( + operation, output); +#else + (void) operation; + (void) output; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +psa_status_t mbedtls_test_transparent_pake_abort( + mbedtls_transparent_test_driver_pake_operation_t *operation) +{ + mbedtls_test_driver_pake_hooks.hits++; + + if (mbedtls_test_driver_pake_hooks.forced_status != PSA_SUCCESS) { + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_test_driver_pake_hooks.forced_status; + } else { +#if defined(MBEDTLS_TEST_LIBTESTDRIVER1) && \ + defined(LIBTESTDRIVER1_MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + libtestdriver1_mbedtls_psa_pake_abort( + operation); +#elif defined(MBEDTLS_PSA_BUILTIN_PAKE) + mbedtls_test_driver_pake_hooks.driver_status = + mbedtls_psa_pake_abort( + operation); +#else + (void) operation; + mbedtls_test_driver_pake_hooks.driver_status = PSA_ERROR_NOT_SUPPORTED; +#endif + } + + return mbedtls_test_driver_pake_hooks.driver_status; +} + +/* + * opaque versions, to do + */ +psa_status_t mbedtls_test_opaque_pake_setup( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const psa_pake_cipher_suite_t *cipher_suite) +{ + (void) operation; + (void) cipher_suite; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_set_password_key( + const psa_key_attributes_t *attributes, + mbedtls_opaque_test_driver_pake_operation_t *operation, + uint8_t *key_buffer, + size_t key_size) +{ + (void) attributes; + (void) operation; + (void) key_buffer; + (void) key_size; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_set_user( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const uint8_t *user_id, + size_t user_id_len) +{ + (void) operation; + (void) user_id; + (void) user_id_len; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_set_peer( + mbedtls_opaque_test_driver_pake_operation_t *operation, + const uint8_t *peer_id, + size_t peer_id_len) +{ + (void) operation; + (void) peer_id; + (void) peer_id_len; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_set_role( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_role_t role) +{ + (void) operation; + (void) role; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_output( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + uint8_t *output, + size_t output_size, + size_t *output_length) +{ + (void) operation; + (void) step; + (void) output; + (void) output_size; + (void) output_length; + + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_input( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_pake_step_t step, + const uint8_t *input, + size_t input_length) +{ + (void) operation; + (void) step; + (void) input; + (void) input_length; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_get_implicit_key( + mbedtls_opaque_test_driver_pake_operation_t *operation, + psa_key_derivation_operation_t *output) +{ + (void) operation; + (void) output; + return PSA_ERROR_NOT_SUPPORTED; +} + +psa_status_t mbedtls_test_opaque_pake_abort( + mbedtls_opaque_test_driver_pake_operation_t *operation) +{ + (void) operation; + return PSA_ERROR_NOT_SUPPORTED; +} + +#endif /* MBEDTLS_PSA_CRYPTO_DRIVERS && PSA_CRYPTO_DRIVER_TEST */