Mbed-TLS/mbedtls
1
0
Fork 0
mirror of https://github.com/Mbed-TLS/mbedtls.git synced 2026-09-04 01:09:59 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
archive/dev/mstarzyk-mobica/code_style_v2
mbedtls/library/psa_crypto_hash.c
T
Mateusz Starzyk c0eabdc636 Apply clang formatting. 
Executed with:
`find . -regextype posix-egrep -regex ".*\.([hc]|fmt|function)" | xargs -L1 clang-format-12 -i`

Signed-off-by: Mateusz Starzyk <[email protected]>
2021-08-11 16:58:05 +02:00

602 lines
20 KiB
C
Raw Permalink Blame History

/*
* PSA hashing layer on top of Mbed TLS software crypto
*/
/*
* 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 "common.h"
#if defined(MBEDTLS_PSA_CRYPTO_C)
# include <psa/crypto.h>
# include "psa_crypto_core.h"
# include "psa_crypto_hash.h"
# include <mbedtls/error.h>
# include <string.h>
/* Use builtin defines specific to this compilation unit, since the test driver
* relies on the software driver. */
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_MD5) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_MD5)))
# define BUILTIN_ALG_MD5 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_RIPEMD160) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_RIPEMD160)))
# define BUILTIN_ALG_RIPEMD160 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_1) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_SHA_1)))
# define BUILTIN_ALG_SHA_1 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_224) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_SHA_224)))
# define BUILTIN_ALG_SHA_224 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_256) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_SHA_256)))
# define BUILTIN_ALG_SHA_256 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_384) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_SHA_384)))
# define BUILTIN_ALG_SHA_384 1
# endif
# if (defined(MBEDTLS_PSA_BUILTIN_ALG_SHA_512) || \
(defined(PSA_CRYPTO_DRIVER_TEST) && \
defined(MBEDTLS_PSA_ACCEL_ALG_SHA_512)))
# define BUILTIN_ALG_SHA_512 1
# endif
# if defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_OAEP) || \
defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) || \
defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA)
const mbedtls_md_info_t *mbedtls_md_info_from_psa(psa_algorithm_t alg)
{
switch (alg) {
# if defined(MBEDTLS_MD5_C)
case PSA_ALG_MD5:
return &mbedtls_md5_info;
# endif
# if defined(MBEDTLS_RIPEMD160_C)
case PSA_ALG_RIPEMD160:
return &mbedtls_ripemd160_info;
# endif
# if defined(MBEDTLS_SHA1_C)
case PSA_ALG_SHA_1:
return &mbedtls_sha1_info;
# endif
# if defined(MBEDTLS_SHA224_C)
case PSA_ALG_SHA_224:
return &mbedtls_sha224_info;
# endif
# if defined(MBEDTLS_SHA256_C)
case PSA_ALG_SHA_256:
return &mbedtls_sha256_info;
# endif
# if defined(MBEDTLS_SHA384_C)
case PSA_ALG_SHA_384:
return &mbedtls_sha384_info;
# endif
# if defined(MBEDTLS_SHA512_C)
case PSA_ALG_SHA_512:
return &mbedtls_sha512_info;
# endif
default:
return NULL;
}
}
# endif /* defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PKCS1V15_SIGN) || \
* defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_OAEP) || \
* defined(MBEDTLS_PSA_BUILTIN_ALG_RSA_PSS) || \
* defined(MBEDTLS_PSA_BUILTIN_ALG_DETERMINISTIC_ECDSA) */
/* Implement the PSA driver hash interface on top of mbed TLS if either the
* software driver or the test driver requires it. */
# if defined(MBEDTLS_PSA_BUILTIN_HASH) || defined(PSA_CRYPTO_DRIVER_TEST)
static psa_status_t hash_abort(mbedtls_psa_hash_operation_t *operation)
{
switch (operation->alg) {
case 0:
/* The object has (apparently) been initialized but it is not
* in use. It's ok to call abort on such an object, and there's
* nothing to do. */
break;
# if defined(BUILTIN_ALG_MD5)
case PSA_ALG_MD5:
mbedtls_md5_free(&operation->ctx.md5);
break;
# endif
# if defined(BUILTIN_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
mbedtls_ripemd160_free(&operation->ctx.ripemd160);
break;
# endif
# if defined(BUILTIN_ALG_SHA_1)
case PSA_ALG_SHA_1:
mbedtls_sha1_free(&operation->ctx.sha1);
break;
# endif
# if defined(BUILTIN_ALG_SHA_224)
case PSA_ALG_SHA_224:
mbedtls_sha256_free(&operation->ctx.sha256);
break;
# endif
# if defined(BUILTIN_ALG_SHA_256)
case PSA_ALG_SHA_256:
mbedtls_sha256_free(&operation->ctx.sha256);
break;
# endif
# if defined(BUILTIN_ALG_SHA_384)
case PSA_ALG_SHA_384:
mbedtls_sha512_free(&operation->ctx.sha512);
break;
# endif
# if defined(BUILTIN_ALG_SHA_512)
case PSA_ALG_SHA_512:
mbedtls_sha512_free(&operation->ctx.sha512);
break;
# endif
default:
return PSA_ERROR_BAD_STATE;
}
operation->alg = 0;
return PSA_SUCCESS;
}
static psa_status_t hash_setup(mbedtls_psa_hash_operation_t *operation,
psa_algorithm_t alg)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
/* A context must be freshly initialized before it can be set up. */
if (operation->alg != 0) {
return PSA_ERROR_BAD_STATE;
}
switch (alg) {
# if defined(BUILTIN_ALG_MD5)
case PSA_ALG_MD5:
mbedtls_md5_init(&operation->ctx.md5);
ret = mbedtls_md5_starts(&operation->ctx.md5);
break;
# endif
# if defined(BUILTIN_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
mbedtls_ripemd160_init(&operation->ctx.ripemd160);
ret = mbedtls_ripemd160_starts(&operation->ctx.ripemd160);
break;
# endif
# if defined(BUILTIN_ALG_SHA_1)
case PSA_ALG_SHA_1:
mbedtls_sha1_init(&operation->ctx.sha1);
ret = mbedtls_sha1_starts(&operation->ctx.sha1);
break;
# endif
# if defined(BUILTIN_ALG_SHA_224)
case PSA_ALG_SHA_224:
mbedtls_sha256_init(&operation->ctx.sha256);
ret = mbedtls_sha256_starts(&operation->ctx.sha256, 1);
break;
# endif
# if defined(BUILTIN_ALG_SHA_256)
case PSA_ALG_SHA_256:
mbedtls_sha256_init(&operation->ctx.sha256);
ret = mbedtls_sha256_starts(&operation->ctx.sha256, 0);
break;
# endif
# if defined(BUILTIN_ALG_SHA_384)
case PSA_ALG_SHA_384:
mbedtls_sha512_init(&operation->ctx.sha512);
ret = mbedtls_sha512_starts(&operation->ctx.sha512, 1);
break;
# endif
# if defined(BUILTIN_ALG_SHA_512)
case PSA_ALG_SHA_512:
mbedtls_sha512_init(&operation->ctx.sha512);
ret = mbedtls_sha512_starts(&operation->ctx.sha512, 0);
break;
# endif
default:
return (PSA_ALG_IS_HASH(alg) ? PSA_ERROR_NOT_SUPPORTED :
PSA_ERROR_INVALID_ARGUMENT);
}
if (ret == 0)
operation->alg = alg;
else
hash_abort(operation);
return mbedtls_to_psa_error(ret);
}
static psa_status_t
hash_clone(const mbedtls_psa_hash_operation_t *source_operation,
mbedtls_psa_hash_operation_t *target_operation)
{
switch (source_operation->alg) {
case 0:
return PSA_ERROR_BAD_STATE;
# if defined(BUILTIN_ALG_MD5)
case PSA_ALG_MD5:
mbedtls_md5_clone(&target_operation->ctx.md5,
&source_operation->ctx.md5);
break;
# endif
# if defined(BUILTIN_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
mbedtls_ripemd160_clone(&target_operation->ctx.ripemd160,
&source_operation->ctx.ripemd160);
break;
# endif
# if defined(BUILTIN_ALG_SHA_1)
case PSA_ALG_SHA_1:
mbedtls_sha1_clone(&target_operation->ctx.sha1,
&source_operation->ctx.sha1);
break;
# endif
# if defined(BUILTIN_ALG_SHA_224)
case PSA_ALG_SHA_224:
mbedtls_sha256_clone(&target_operation->ctx.sha256,
&source_operation->ctx.sha256);
break;
# endif
# if defined(BUILTIN_ALG_SHA_256)
case PSA_ALG_SHA_256:
mbedtls_sha256_clone(&target_operation->ctx.sha256,
&source_operation->ctx.sha256);
break;
# endif
# if defined(BUILTIN_ALG_SHA_384)
case PSA_ALG_SHA_384:
mbedtls_sha512_clone(&target_operation->ctx.sha512,
&source_operation->ctx.sha512);
break;
# endif
# if defined(BUILTIN_ALG_SHA_512)
case PSA_ALG_SHA_512:
mbedtls_sha512_clone(&target_operation->ctx.sha512,
&source_operation->ctx.sha512);
break;
# endif
default:
(void)source_operation;
(void)target_operation;
return PSA_ERROR_NOT_SUPPORTED;
}
target_operation->alg = source_operation->alg;
return PSA_SUCCESS;
}
static psa_status_t hash_update(mbedtls_psa_hash_operation_t *operation,
const uint8_t *input,
size_t input_length)
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
switch (operation->alg) {
# if defined(BUILTIN_ALG_MD5)
case PSA_ALG_MD5:
ret = mbedtls_md5_update(&operation->ctx.md5, input, input_length);
break;
# endif
# if defined(BUILTIN_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
ret = mbedtls_ripemd160_update(&operation->ctx.ripemd160, input,
input_length);
break;
# endif
# if defined(BUILTIN_ALG_SHA_1)
case PSA_ALG_SHA_1:
ret =
mbedtls_sha1_update(&operation->ctx.sha1, input, input_length);
break;
# endif
# if defined(BUILTIN_ALG_SHA_224)
case PSA_ALG_SHA_224:
ret = mbedtls_sha256_update(&operation->ctx.sha256, input,
input_length);
break;
# endif
# if defined(BUILTIN_ALG_SHA_256)
case PSA_ALG_SHA_256:
ret = mbedtls_sha256_update(&operation->ctx.sha256, input,
input_length);
break;
# endif
# if defined(BUILTIN_ALG_SHA_384)
case PSA_ALG_SHA_384:
ret = mbedtls_sha512_update(&operation->ctx.sha512, input,
input_length);
break;
# endif
# if defined(BUILTIN_ALG_SHA_512)
case PSA_ALG_SHA_512:
ret = mbedtls_sha512_update(&operation->ctx.sha512, input,
input_length);
break;
# endif
default:
(void)input;
(void)input_length;
return PSA_ERROR_BAD_STATE;
}
return mbedtls_to_psa_error(ret);
}
static psa_status_t hash_finish(mbedtls_psa_hash_operation_t *operation,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
psa_status_t status;
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t actual_hash_length = PSA_HASH_LENGTH(operation->alg);
/* Fill the output buffer with something that isn't a valid hash
* (barring an attack on the hash and deliberately-crafted input),
* in case the caller doesn't check the return status properly. */
*hash_length = hash_size;
/* If hash_size is 0 then hash may be NULL and then the
* call to memset would have undefined behavior. */
if (hash_size != 0)
memset(hash, '!', hash_size);
if (hash_size < actual_hash_length) {
status = PSA_ERROR_BUFFER_TOO_SMALL;
goto exit;
}
switch (operation->alg) {
# if defined(BUILTIN_ALG_MD5)
case PSA_ALG_MD5:
ret = mbedtls_md5_finish(&operation->ctx.md5, hash);
break;
# endif
# if defined(BUILTIN_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
ret = mbedtls_ripemd160_finish(&operation->ctx.ripemd160, hash);
break;
# endif
# if defined(BUILTIN_ALG_SHA_1)
case PSA_ALG_SHA_1:
ret = mbedtls_sha1_finish(&operation->ctx.sha1, hash);
break;
# endif
# if defined(BUILTIN_ALG_SHA_224)
case PSA_ALG_SHA_224:
ret = mbedtls_sha256_finish(&operation->ctx.sha256, hash);
break;
# endif
# if defined(BUILTIN_ALG_SHA_256)
case PSA_ALG_SHA_256:
ret = mbedtls_sha256_finish(&operation->ctx.sha256, hash);
break;
# endif
# if defined(BUILTIN_ALG_SHA_384)
case PSA_ALG_SHA_384:
ret = mbedtls_sha512_finish(&operation->ctx.sha512, hash);
break;
# endif
# if defined(BUILTIN_ALG_SHA_512)
case PSA_ALG_SHA_512:
ret = mbedtls_sha512_finish(&operation->ctx.sha512, hash);
break;
# endif
default:
(void)hash;
return PSA_ERROR_BAD_STATE;
}
status = mbedtls_to_psa_error(ret);
exit:
if (status == PSA_SUCCESS)
*hash_length = actual_hash_length;
return status;
}
static psa_status_t hash_compute(psa_algorithm_t alg,
const uint8_t *input,
size_t input_length,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
mbedtls_psa_hash_operation_t operation = MBEDTLS_PSA_HASH_OPERATION_INIT;
psa_status_t status = PSA_ERROR_CORRUPTION_DETECTED;
psa_status_t abort_status = PSA_ERROR_CORRUPTION_DETECTED;
*hash_length = hash_size;
status = hash_setup(&operation, alg);
if (status != PSA_SUCCESS)
goto exit;
status = hash_update(&operation, input, input_length);
if (status != PSA_SUCCESS)
goto exit;
status = hash_finish(&operation, hash, hash_size, hash_length);
if (status != PSA_SUCCESS)
goto exit;
exit:
abort_status = hash_abort(&operation);
if (status == PSA_SUCCESS)
return abort_status;
else
return status;
}
# endif /* MBEDTLS_PSA_BUILTIN_HASH || PSA_CRYPTO_DRIVER_TEST */
# if defined(MBEDTLS_PSA_BUILTIN_HASH)
psa_status_t mbedtls_psa_hash_compute(psa_algorithm_t alg,
const uint8_t *input,
size_t input_length,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
return (
hash_compute(alg, input, input_length, hash, hash_size, hash_length));
}
psa_status_t mbedtls_psa_hash_setup(mbedtls_psa_hash_operation_t *operation,
psa_algorithm_t alg)
{
return hash_setup(operation, alg);
}
psa_status_t
mbedtls_psa_hash_clone(const mbedtls_psa_hash_operation_t *source_operation,
mbedtls_psa_hash_operation_t *target_operation)
{
return hash_clone(source_operation, target_operation);
}
psa_status_t mbedtls_psa_hash_update(mbedtls_psa_hash_operation_t *operation,
const uint8_t *input,
size_t input_length)
{
return hash_update(operation, input, input_length);
}
psa_status_t mbedtls_psa_hash_finish(mbedtls_psa_hash_operation_t *operation,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
return hash_finish(operation, hash, hash_size, hash_length);
}
psa_status_t mbedtls_psa_hash_abort(mbedtls_psa_hash_operation_t *operation)
{
return hash_abort(operation);
}
# endif /* MBEDTLS_PSA_BUILTIN_HASH */
/*
* BEYOND THIS POINT, TEST DRIVER ENTRY POINTS ONLY.
*/
# if defined(PSA_CRYPTO_DRIVER_TEST)
static int is_hash_accelerated(psa_algorithm_t alg)
{
switch (alg) {
# if defined(MBEDTLS_PSA_ACCEL_ALG_MD5)
case PSA_ALG_MD5:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_RIPEMD160)
case PSA_ALG_RIPEMD160:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_SHA_1)
case PSA_ALG_SHA_1:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_SHA_224)
case PSA_ALG_SHA_224:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_SHA_256)
case PSA_ALG_SHA_256:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_SHA_384)
case PSA_ALG_SHA_384:
return 1;
# endif
# if defined(MBEDTLS_PSA_ACCEL_ALG_SHA_512)
case PSA_ALG_SHA_512:
return 1;
# endif
default:
return 0;
}
}
psa_status_t mbedtls_transparent_test_driver_hash_compute(psa_algorithm_t alg,
const uint8_t *input,
size_t input_length,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
if (is_hash_accelerated(alg))
return (hash_compute(alg, input, input_length, hash, hash_size,
hash_length));
else
return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_transparent_test_driver_hash_setup(
mbedtls_transparent_test_driver_hash_operation_t *operation,
psa_algorithm_t alg)
{
if (is_hash_accelerated(alg))
return hash_setup(operation, alg);
else
return PSA_ERROR_NOT_SUPPORTED;
}
psa_status_t mbedtls_transparent_test_driver_hash_clone(
const mbedtls_transparent_test_driver_hash_operation_t *source_operation,
mbedtls_transparent_test_driver_hash_operation_t *target_operation)
{
if (is_hash_accelerated(source_operation->alg))
return hash_clone(source_operation, target_operation);
else
return PSA_ERROR_BAD_STATE;
}
psa_status_t mbedtls_transparent_test_driver_hash_update(
mbedtls_transparent_test_driver_hash_operation_t *operation,
const uint8_t *input,
size_t input_length)
{
if (is_hash_accelerated(operation->alg))
return hash_update(operation, input, input_length);
else
return PSA_ERROR_BAD_STATE;
}
psa_status_t mbedtls_transparent_test_driver_hash_finish(
mbedtls_transparent_test_driver_hash_operation_t *operation,
uint8_t *hash,
size_t hash_size,
size_t *hash_length)
{
if (is_hash_accelerated(operation->alg))
return hash_finish(operation, hash, hash_size, hash_length);
else
return PSA_ERROR_BAD_STATE;
}
psa_status_t mbedtls_transparent_test_driver_hash_abort(
mbedtls_transparent_test_driver_hash_operation_t *operation)
{
return hash_abort(operation);
}
# endif /* PSA_CRYPTO_DRIVER_TEST */
#endif /* MBEDTLS_PSA_CRYPTO_C */
Reference in New Issue View Git Blame Copy Permalink