diff --git a/include/mbedtls/md.h b/include/mbedtls/md.h index 2810a9180..120473d94 100644 --- a/include/mbedtls/md.h +++ b/include/mbedtls/md.h @@ -131,6 +131,8 @@ static inline mbedtls_md_handle_t mbedtls_md_get_handle( } #endif /* !MBEDTLS_MD_SINGLE_HASH */ +#include "md_internal.h" + /** * \brief This function returns the list of digests supported by the * generic digest module. diff --git a/include/mbedtls/md_internal.h b/include/mbedtls/md_internal.h new file mode 100644 index 000000000..568c9714b --- /dev/null +++ b/include/mbedtls/md_internal.h @@ -0,0 +1,820 @@ + /** + * \file md.h + * + * \brief This file contains the generic message-digest wrapper. + * + * \author Adriaan de Jong + */ +/* + * Copyright (C) 2006-2018, Arm Limited (or its affiliates), All Rights Reserved + * 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. + * + * This file is part of Mbed TLS (https://tls.mbed.org) + */ + +#ifndef MBEDTLS_MD_INTERNAL_H +#define MBEDTLS_MD_INTERNAL_H + +#if defined(MBEDTLS_MD2_C) +#include "mbedtls/md2.h" +#endif + +#if defined(MBEDTLS_MD4_C) +#include "mbedtls/md4.h" +#endif + +#if defined(MBEDTLS_MD5_C) +#include "mbedtls/md5.h" +#endif + +#if defined(MBEDTLS_RIPEMD160_C) +#include "mbedtls/ripemd160.h" +#endif + +#if defined(MBEDTLS_SHA1_C) +#include "mbedtls/sha1.h" +#endif + +#if defined(MBEDTLS_SHA256_C) +#include "mbedtls/sha256.h" +#endif + +#if defined(MBEDTLS_SHA512_C) +#include "mbedtls/sha512.h" +#endif + +#include "mbedtls/platform_util.h" + +#if defined(MBEDTLS_PLATFORM_C) +#include "mbedtls/platform.h" +#else +#include +#define mbedtls_calloc calloc +#define mbedtls_free free +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Message-digest information macro definition + */ + +/* SHA-256 */ +#define MBEDTLS_MD_INFO_SHA256_TYPE MBEDTLS_MD_SHA256 +#define MBEDTLS_MD_INFO_SHA256_NAME "SHA256" +#define MBEDTLS_MD_INFO_SHA256_SIZE 32 +#define MBEDTLS_MD_INFO_SHA256_BLOCKSIZE 64 +#define MBEDTLS_MD_INFO_SHA256_STARTS_FUNC mbedtls_sha256_starts_wrap +#define MBEDTLS_MD_INFO_SHA256_UPDATE_FUNC mbedtls_sha224_update_wrap +#define MBEDTLS_MD_INFO_SHA256_FINISH_FUNC mbedtls_sha224_finish_wrap +#define MBEDTLS_MD_INFO_SHA256_DIGEST_FUNC mbedtls_sha256_wrap +#define MBEDTLS_MD_INFO_SHA256_ALLOC_FUNC mbedtls_sha224_ctx_alloc +#define MBEDTLS_MD_INFO_SHA256_FREE_FUNC mbedtls_sha224_ctx_free +#define MBEDTLS_MD_INFO_SHA256_CLONE_FUNC mbedtls_sha224_clone_wrap +#define MBEDTLS_MD_INFO_SHA256_PROCESS_FUNC mbedtls_sha224_process_wrap + +/* + * Helper macros to extract fields from ciphersuites. + */ + +#define MBEDTLS_MD_INFO_TYPE_T( MD ) MD ## _TYPE +#define MBEDTLS_MD_INFO_NAME_T( MD ) MD ## _NAME +#define MBEDTLS_MD_INFO_SIZE_T( MD ) MD ## _SIZE +#define MBEDTLS_MD_INFO_BLOCKSIZE_T( MD ) MD ## _BLOCKSIZE +#define MBEDTLS_MD_INFO_STARTS_FUNC_T( MD ) MD ## _STARTS_FUNC +#define MBEDTLS_MD_INFO_UPDATE_FUNC_T( MD ) MD ## _UPDATE_FUNC +#define MBEDTLS_MD_INFO_FINISH_FUNC_T( MD ) MD ## _FINISH_FUNC +#define MBEDTLS_MD_INFO_DIGEST_FUNC_T( MD ) MD ## _DIGEST_FUNC +#define MBEDTLS_MD_INFO_ALLOC_FUNC_T( MD ) MD ## _ALLOC_FUNC +#define MBEDTLS_MD_INFO_FREE_FUNC_T( MD ) MD ## _FREE_FUNC +#define MBEDTLS_MD_INFO_CLONE_FUNC_T( MD ) MD ## _CLONE_FUNC +#define MBEDTLS_MD_INFO_PROCESS_FUNC_T( MD ) MD ## _PROCESS_FUNC + +/* Wrapper around MBEDTLS_MD_INFO_XXX_T() which makes sure that + * the argument is macro-expanded before concatenated with the + * field name. This allows to call these macros as + * MBEDTLS_MD_INFO_XXX( MBEDTLS_MD_SINGLE_HASH ). + * where MBEDTLS_MD_SINGLE_HASH expands to MBEDTLS_MD_INFO_XXX. */ +#define MBEDTLS_MD_INFO_TYPE( MD ) MBEDTLS_MD_INFO_TYPE_T( MD ) +#define MBEDTLS_MD_INFO_NAME( MD ) MBEDTLS_MD_INFO_NAME_T( MD ) +#define MBEDTLS_MD_INFO_SIZE( MD ) MBEDTLS_MD_INFO_SIZE_T( MD ) +#define MBEDTLS_MD_INFO_BLOCKSIZE( MD ) MBEDTLS_MD_INFO_BLOCKSIZE_T( MD ) +#define MBEDTLS_MD_INFO_STARTS_FUNC( MD ) MBEDTLS_MD_INFO_STARTS_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_UPDATE_FUNC( MD ) MBEDTLS_MD_INFO_UPDATE_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_FINISH_FUNC( MD ) MBEDTLS_MD_INFO_FINISH_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_DIGEST_FUNC( MD ) MBEDTLS_MD_INFO_DIGEST_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_ALLOC_FUNC( MD ) MBEDTLS_MD_INFO_ALLOC_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_FREE_FUNC( MD ) MBEDTLS_MD_INFO_FREE_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_CLONE_FUNC( MD ) MBEDTLS_MD_INFO_CLONE_FUNC_T( MD ) +#define MBEDTLS_MD_INFO_PROCESS_FUNC( MD ) MBEDTLS_MD_INFO_PROCESS_FUNC_T( MD ) + +/** + * Message digest information. + * Allows message digest functions to be called in a generic way. + */ + +typedef int mbedtls_md_starts_func_t( void *ctx ); +typedef int mbedtls_md_update_func_t( void *ctx, + const unsigned char *input, + size_t ilen ); +typedef int mbedtls_md_finish_func_t( void *ctx, unsigned char *output ); +typedef int mbedtls_md_digest_func_t( const unsigned char *input, + size_t ilen, + unsigned char *output ); +typedef void* mbedtls_md_ctx_alloc_func_t( void ); +typedef void mbedtls_md_ctx_free_func_t( void *ctx ); +typedef void mbedtls_md_clone_func_t( void *st, const void *src ); +typedef int mbedtls_md_process_func_t( void *ctx, + const unsigned char *input ); + +#if !defined(MBEDTLS_MD_SINGLE_HASH) +struct mbedtls_md_info_t +{ + /** Digest identifier */ + mbedtls_md_type_t type; + + /** Name of the message digest */ + const char * name; + + /** Output length of the digest function in bytes */ + int size; + + /** Block length of the digest function in bytes */ + int block_size; + + /** Digest initialisation function */ + mbedtls_md_starts_func_t *starts_func; + + /** Digest update function */ + mbedtls_md_update_func_t *update_func; + + /** Digest finalisation function */ + mbedtls_md_finish_func_t *finish_func; + + /** Generic digest function */ + mbedtls_md_digest_func_t *digest_func; + + /** Allocate a new context */ + mbedtls_md_ctx_alloc_func_t *ctx_alloc_func; + + /** Free the given context */ + mbedtls_md_ctx_free_func_t *ctx_free_func; + + /** Clone state from a context */ + mbedtls_md_clone_func_t *clone_func; + + /** Internal use only */ + mbedtls_md_process_func_t *process_func; +}; + +/** + * \brief This macro builds an instance of ::mbedtls_md_info_t + * from an \c MBEDTLS_MD_INFO_XXX identifier. + */ +#define MBEDTLS_MD_INFO( MD ) \ + { MBEDTLS_MD_INFO_TYPE( MD ), \ + MBEDTLS_MD_INFO_NAME( MD ), \ + MBEDTLS_MD_INFO_SIZE( MD ), \ + MBEDTLS_MD_INFO_BLOCKSIZE( MD ), \ + MBEDTLS_MD_INFO_STARTS_FUNC( MD ), \ + MBEDTLS_MD_INFO_UPDATE_FUNC( MD ), \ + MBEDTLS_MD_INFO_FINISH_FUNC( MD ), \ + MBEDTLS_MD_INFO_DIGEST_FUNC( MD ), \ + MBEDTLS_MD_INFO_ALLOC_FUNC( MD ), \ + MBEDTLS_MD_INFO_FREE_FUNC( MD ), \ + MBEDTLS_MD_INFO_CLONE_FUNC( MD ), \ + MBEDTLS_MD_INFO_PROCESS_FUNC( MD ) } + +#endif /* !MBEDTLS_MD_SINGLE_HASH */ + +/* + * + * Definitions of MD information structures for various digests. + * + */ + +/* + * MD-2 + */ + +#if defined(MBEDTLS_MD2_C) + +static int mbedtls_md2_starts_wrap( void *ctx ) +{ + return( mbedtls_md2_starts_ret( (mbedtls_md2_context *) ctx ) ); +} + +static int mbedtls_md2_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_md2_update_ret( (mbedtls_md2_context *) ctx, input, ilen ) ); +} + +static int mbedtls_md2_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_md2_finish_ret( (mbedtls_md2_context *) ctx, output ) ); +} + +static void* mbedtls_md2_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md2_context ) ); + + if( ctx != NULL ) + mbedtls_md2_init( (mbedtls_md2_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_md2_ctx_free( void *ctx ) +{ + mbedtls_md2_free( (mbedtls_md2_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_md2_clone_wrap( void *dst, const void *src ) +{ + mbedtls_md2_clone( (mbedtls_md2_context *) dst, + (const mbedtls_md2_context *) src ); +} + +static int mbedtls_md2_process_wrap( void *ctx, const unsigned char *data ) +{ + ((void) data); + + return( mbedtls_internal_md2_process( (mbedtls_md2_context *) ctx ) ); +} + +#endif /* MBEDTLS_MD2_C */ + +/* + * MD-4 + */ + +#if defined(MBEDTLS_MD4_C) + +static int mbedtls_md4_starts_wrap( void *ctx ) +{ + return( mbedtls_md4_starts_ret( (mbedtls_md4_context *) ctx ) ); +} + +static int mbedtls_md4_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_md4_update_ret( (mbedtls_md4_context *) ctx, input, ilen ) ); +} + +static int mbedtls_md4_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_md4_finish_ret( (mbedtls_md4_context *) ctx, output ) ); +} + +static void* mbedtls_md4_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md4_context ) ); + + if( ctx != NULL ) + mbedtls_md4_init( (mbedtls_md4_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_md4_ctx_free( void *ctx ) +{ + mbedtls_md4_free( (mbedtls_md4_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_md4_clone_wrap( void *dst, const void *src ) +{ + mbedtls_md4_clone( (mbedtls_md4_context *) dst, + (const mbedtls_md4_context *) src ); +} + +static int mbedtls_md4_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_md4_process( (mbedtls_md4_context *) ctx, data ) ); +} + +#endif /* MBEDTLS_MD4_C */ + +/* + * MD-5 + */ + +#if defined(MBEDTLS_MD5_C) + +static int mbedtls_md5_starts_wrap( void *ctx ) +{ + return( mbedtls_md5_starts_ret( (mbedtls_md5_context *) ctx ) ); +} + +static int mbedtls_md5_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_md5_update_ret( (mbedtls_md5_context *) ctx, input, ilen ) ); +} + +static int mbedtls_md5_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_md5_finish_ret( (mbedtls_md5_context *) ctx, output ) ); +} + +static void* mbedtls_md5_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md5_context ) ); + + if( ctx != NULL ) + mbedtls_md5_init( (mbedtls_md5_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_md5_ctx_free( void *ctx ) +{ + mbedtls_md5_free( (mbedtls_md5_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_md5_clone_wrap( void *dst, const void *src ) +{ + mbedtls_md5_clone( (mbedtls_md5_context *) dst, + (const mbedtls_md5_context *) src ); +} + +static int mbedtls_md5_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_md5_process( (mbedtls_md5_context *) ctx, data ) ); +} + +#endif /* MBEDTLS_MD5_C */ + +/* + * RIPEMD-160 + */ + +#if defined(MBEDTLS_RIPEMD160_C) + +static int mbedtls_ripemd160_starts_wrap( void *ctx ) +{ + return( mbedtls_ripemd160_starts_ret( (mbedtls_ripemd160_context *) ctx ) ); +} + +static int mbedtls_ripemd160_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_ripemd160_update_ret( (mbedtls_ripemd160_context *) ctx, + input, ilen ) ); +} + +static int mbedtls_ripemd160_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_ripemd160_finish_ret( (mbedtls_ripemd160_context *) ctx, + output ) ); +} + +static void* mbedtls_ripemd160_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ripemd160_context ) ); + + if( ctx != NULL ) + mbedtls_ripemd160_init( (mbedtls_ripemd160_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_ripemd160_ctx_free( void *ctx ) +{ + mbedtls_ripemd160_free( (mbedtls_ripemd160_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_ripemd160_clone_wrap( void *dst, const void *src ) +{ + mbedtls_ripemd160_clone( (mbedtls_ripemd160_context *) dst, + (const mbedtls_ripemd160_context *) src ); +} + +static int mbedtls_ripemd160_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_ripemd160_process( + (mbedtls_ripemd160_context *) ctx, data ) ); +} + +#endif /* MBEDTLS_RIPEMD160_C */ + +/* + * SHA-1 + */ + +#if defined(MBEDTLS_SHA1_C) + +static int mbedtls_sha1_starts_wrap( void *ctx ) +{ + return( mbedtls_sha1_starts_ret( (mbedtls_sha1_context *) ctx ) ); +} + +static int mbedtls_sha1_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_sha1_update_ret( (mbedtls_sha1_context *) ctx, + input, ilen ) ); +} + +static int mbedtls_sha1_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_sha1_finish_ret( (mbedtls_sha1_context *) ctx, output ) ); +} + +static void* mbedtls_sha1_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha1_context ) ); + + if( ctx != NULL ) + mbedtls_sha1_init( (mbedtls_sha1_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_sha1_clone_wrap( void *dst, const void *src ) +{ + mbedtls_sha1_clone( (mbedtls_sha1_context *) dst, + (const mbedtls_sha1_context *) src ); +} + +static void mbedtls_sha1_ctx_free( void *ctx ) +{ + mbedtls_sha1_free( (mbedtls_sha1_context *) ctx ); + mbedtls_free( ctx ); +} + +static int mbedtls_sha1_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_sha1_process( (mbedtls_sha1_context *) ctx, + data ) ); +} + +#endif /* MBEDTLS_SHA1_C */ + +/* + * SHA-224 and SHA-256 + */ + +#if defined(MBEDTLS_SHA256_C) + +#if !defined(MBEDTLS_SHA256_NO_SHA224) +static int mbedtls_sha224_starts_wrap( void *ctx ) +{ + return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 1 ) ); +} +#endif /* !MBEDTLS_SHA256_NO_SHA224 */ + +static int mbedtls_sha224_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_sha256_update_ret( (mbedtls_sha256_context *) ctx, + input, ilen ) ); +} + +static int mbedtls_sha224_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_sha256_finish_ret( (mbedtls_sha256_context *) ctx, + output ) ); +} + +#if !defined(MBEDTLS_SHA256_NO_SHA224) +static int mbedtls_sha224_wrap( const unsigned char *input, size_t ilen, + unsigned char *output ) +{ + return( mbedtls_sha256_ret( input, ilen, output, 1 ) ); +} +#endif /* !MBEDTLS_SHA256_NO_SHA224 */ + +static void* mbedtls_sha224_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha256_context ) ); + + if( ctx != NULL ) + mbedtls_sha256_init( (mbedtls_sha256_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_sha224_ctx_free( void *ctx ) +{ + mbedtls_sha256_free( (mbedtls_sha256_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_sha224_clone_wrap( void *dst, const void *src ) +{ + mbedtls_sha256_clone( (mbedtls_sha256_context *) dst, + (const mbedtls_sha256_context *) src ); +} + +static int mbedtls_sha224_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_sha256_process( (mbedtls_sha256_context *) ctx, + data ) ); +} + +static int mbedtls_sha256_starts_wrap( void *ctx ) +{ + return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 0 ) ); +} + +static int mbedtls_sha256_wrap( const unsigned char *input, size_t ilen, + unsigned char *output ) +{ + return( mbedtls_sha256_ret( input, ilen, output, 0 ) ); +} + +#endif /* MBEDTLS_SHA256_C */ + +/* + * SHA-384 and SHA-512 + */ + +#if defined(MBEDTLS_SHA512_C) + +static int mbedtls_sha384_starts_wrap( void *ctx ) +{ + return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 1 ) ); +} + +static int mbedtls_sha384_update_wrap( void *ctx, const unsigned char *input, + size_t ilen ) +{ + return( mbedtls_sha512_update_ret( (mbedtls_sha512_context *) ctx, + input, ilen ) ); +} + +static int mbedtls_sha384_finish_wrap( void *ctx, unsigned char *output ) +{ + return( mbedtls_sha512_finish_ret( (mbedtls_sha512_context *) ctx, + output ) ); +} + +static int mbedtls_sha384_wrap( const unsigned char *input, size_t ilen, + unsigned char *output ) +{ + return( mbedtls_sha512_ret( input, ilen, output, 1 ) ); +} + +static void* mbedtls_sha384_ctx_alloc( void ) +{ + void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha512_context ) ); + + if( ctx != NULL ) + mbedtls_sha512_init( (mbedtls_sha512_context *) ctx ); + + return( ctx ); +} + +static void mbedtls_sha384_ctx_free( void *ctx ) +{ + mbedtls_sha512_free( (mbedtls_sha512_context *) ctx ); + mbedtls_free( ctx ); +} + +static void mbedtls_sha384_clone_wrap( void *dst, const void *src ) +{ + mbedtls_sha512_clone( (mbedtls_sha512_context *) dst, + (const mbedtls_sha512_context *) src ); +} + +static int mbedtls_sha384_process_wrap( void *ctx, const unsigned char *data ) +{ + return( mbedtls_internal_sha512_process( (mbedtls_sha512_context *) ctx, + data ) ); +} + +static int mbedtls_sha512_starts_wrap( void *ctx ) +{ + return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 0 ) ); +} + +static int mbedtls_sha512_wrap( const unsigned char *input, size_t ilen, + unsigned char *output ) +{ + return( mbedtls_sha512_ret( input, ilen, output, 0 ) ); +} + +#endif /* MBEDTLS_SHA512_C */ + +/* + * Getter functions for MD info structure. + */ + +#if !defined(MBEDTLS_MD_SINGLE_HASH) + +MBEDTLS_ALWAYS_INLINE static inline mbedtls_md_type_t mbedtls_md_info_type( + mbedtls_md_handle_t info ) +{ + return( info->type ); +} + +MBEDTLS_ALWAYS_INLINE static inline const char * mbedtls_md_info_name( + mbedtls_md_handle_t info ) +{ + return( info->name ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_size( + mbedtls_md_handle_t info ) +{ + return( info->size ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_block_size( + mbedtls_md_handle_t info ) +{ + return( info->block_size ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_starts( + mbedtls_md_handle_t info, + void *ctx ) +{ + return( info->starts_func( ctx ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_update( + mbedtls_md_handle_t info, + void *ctx, + const unsigned char *input, + size_t ilen ) +{ + return( info->update_func( ctx, input, ilen ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_finish( + mbedtls_md_handle_t info, + void *ctx, + unsigned char *output ) +{ + return( info->finish_func( ctx, output ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_digest( + mbedtls_md_handle_t info, + const unsigned char *input, + size_t ilen, + unsigned char *output ) +{ + return( info->digest_func( input, ilen, output ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline void* mbedtls_md_info_ctx_alloc( + mbedtls_md_handle_t info ) +{ + return( info->ctx_alloc_func() ); +} + +MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_ctx_free( + mbedtls_md_handle_t info, + void *ctx ) +{ + info->ctx_free_func( ctx ); +} + +MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_clone( + mbedtls_md_handle_t info, + void *dst, + const void *src ) +{ + info->clone_func( dst, src ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_process( + mbedtls_md_handle_t info, + void *ctx, + const unsigned char *input ) +{ + return( info->process_func( ctx, input ) ); +} + +#else /* !MBEDTLS_MD_SINGLE_HASH */ + +MBEDTLS_ALWAYS_INLINE static inline mbedtls_md_type_t mbedtls_md_info_type( + mbedtls_md_handle_t info ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_TYPE( MBEDTLS_MD_SINGLE_HASH ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline const char * mbedtls_md_info_name( + mbedtls_md_handle_t info ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_NAME( MBEDTLS_MD_SINGLE_HASH ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_size( + mbedtls_md_handle_t info ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_SIZE( MBEDTLS_MD_SINGLE_HASH ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_block_size( + mbedtls_md_handle_t info ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_BLOCKSIZE( MBEDTLS_MD_SINGLE_HASH ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_starts( + mbedtls_md_handle_t info, + void *ctx ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_STARTS_FUNC( MBEDTLS_MD_SINGLE_HASH )( ctx ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_update( + mbedtls_md_handle_t info, + void *ctx, + const unsigned char *input, + size_t ilen ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_UPDATE_FUNC( MBEDTLS_MD_SINGLE_HASH ) + ( ctx, input, ilen ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_finish( + mbedtls_md_handle_t info, + void *ctx, + unsigned char *output ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_FINISH_FUNC( MBEDTLS_MD_SINGLE_HASH ) + ( ctx, output ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_digest( + mbedtls_md_handle_t info, + const unsigned char *input, + size_t ilen, + unsigned char *output ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_DIGEST_FUNC( MBEDTLS_MD_SINGLE_HASH ) + ( input, ilen, output ) ); +} + +MBEDTLS_ALWAYS_INLINE static inline void* mbedtls_md_info_ctx_alloc( + mbedtls_md_handle_t info ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_ALLOC_FUNC( MBEDTLS_MD_SINGLE_HASH )() ); +} + +MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_ctx_free( + mbedtls_md_handle_t info, + void *ctx ) +{ + ((void) info); + MBEDTLS_MD_INFO_FREE_FUNC( MBEDTLS_MD_SINGLE_HASH )( ctx ); +} + +MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_clone( + mbedtls_md_handle_t info, + void *dst, + const void *src ) +{ + ((void) info); + MBEDTLS_MD_INFO_CLONE_FUNC( MBEDTLS_MD_SINGLE_HASH )( dst, src ); +} + +MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_process( + mbedtls_md_handle_t info, + void *ctx, + const unsigned char *input ) +{ + ((void) info); + return( MBEDTLS_MD_INFO_PROCESS_FUNC( MBEDTLS_MD_SINGLE_HASH ) + ( ctx, input ) ); +} + +#endif /* MBEDTLS_MD_SINGLE_HASH */ + +#ifdef __cplusplus +} +#endif + +#endif /* MBEDTLS_MD_INTERNAL_H */ diff --git a/library/md.c b/library/md.c index 8d8f3371a..f81a1a9e3 100644 --- a/library/md.c +++ b/library/md.c @@ -48,166 +48,7 @@ #include #endif -#if defined(MBEDTLS_MD2_C) -#include "mbedtls/md2.h" -#endif - -#if defined(MBEDTLS_MD4_C) -#include "mbedtls/md4.h" -#endif - -#if defined(MBEDTLS_MD5_C) -#include "mbedtls/md5.h" -#endif - -#if defined(MBEDTLS_RIPEMD160_C) -#include "mbedtls/ripemd160.h" -#endif - -#if defined(MBEDTLS_SHA1_C) -#include "mbedtls/sha1.h" -#endif - -#if defined(MBEDTLS_SHA256_C) -#include "mbedtls/sha256.h" -#endif - -#if defined(MBEDTLS_SHA512_C) -#include "mbedtls/sha512.h" -#endif - -/* - * Message-digest information macro definition - */ - -/* SHA-256 */ -#define MBEDTLS_MD_INFO_SHA256_TYPE MBEDTLS_MD_SHA256 -#define MBEDTLS_MD_INFO_SHA256_NAME "SHA256" -#define MBEDTLS_MD_INFO_SHA256_SIZE 32 -#define MBEDTLS_MD_INFO_SHA256_BLOCKSIZE 64 -#define MBEDTLS_MD_INFO_SHA256_STARTS_FUNC sha256_starts_wrap -#define MBEDTLS_MD_INFO_SHA256_UPDATE_FUNC sha224_update_wrap -#define MBEDTLS_MD_INFO_SHA256_FINISH_FUNC sha224_finish_wrap -#define MBEDTLS_MD_INFO_SHA256_DIGEST_FUNC sha256_wrap -#define MBEDTLS_MD_INFO_SHA256_ALLOC_FUNC sha224_ctx_alloc -#define MBEDTLS_MD_INFO_SHA256_FREE_FUNC sha224_ctx_free -#define MBEDTLS_MD_INFO_SHA256_CLONE_FUNC sha224_clone_wrap -#define MBEDTLS_MD_INFO_SHA256_PROCESS_FUNC sha224_process_wrap - -/* - * Helper macros to extract fields from ciphersuites. - */ - -#define MBEDTLS_MD_INFO_TYPE_T( MD ) MD ## _TYPE -#define MBEDTLS_MD_INFO_NAME_T( MD ) MD ## _NAME -#define MBEDTLS_MD_INFO_SIZE_T( MD ) MD ## _SIZE -#define MBEDTLS_MD_INFO_BLOCKSIZE_T( MD ) MD ## _BLOCKSIZE -#define MBEDTLS_MD_INFO_STARTS_FUNC_T( MD ) MD ## _STARTS_FUNC -#define MBEDTLS_MD_INFO_UPDATE_FUNC_T( MD ) MD ## _UPDATE_FUNC -#define MBEDTLS_MD_INFO_FINISH_FUNC_T( MD ) MD ## _FINISH_FUNC -#define MBEDTLS_MD_INFO_DIGEST_FUNC_T( MD ) MD ## _DIGEST_FUNC -#define MBEDTLS_MD_INFO_ALLOC_FUNC_T( MD ) MD ## _ALLOC_FUNC -#define MBEDTLS_MD_INFO_FREE_FUNC_T( MD ) MD ## _FREE_FUNC -#define MBEDTLS_MD_INFO_CLONE_FUNC_T( MD ) MD ## _CLONE_FUNC -#define MBEDTLS_MD_INFO_PROCESS_FUNC_T( MD ) MD ## _PROCESS_FUNC - -/* Wrapper around MBEDTLS_MD_INFO_XXX_T() which makes sure that - * the argument is macro-expanded before concatenated with the - * field name. This allows to call these macros as - * MBEDTLS_MD_INFO_XXX( MBEDTLS_MD_SINGLE_HASH ). - * where MBEDTLS_MD_SINGLE_HASH expands to MBEDTLS_MD_INFO_XXX. */ -#define MBEDTLS_MD_INFO_TYPE( MD ) MBEDTLS_MD_INFO_TYPE_T( MD ) -#define MBEDTLS_MD_INFO_NAME( MD ) MBEDTLS_MD_INFO_NAME_T( MD ) -#define MBEDTLS_MD_INFO_SIZE( MD ) MBEDTLS_MD_INFO_SIZE_T( MD ) -#define MBEDTLS_MD_INFO_BLOCKSIZE( MD ) MBEDTLS_MD_INFO_BLOCKSIZE_T( MD ) -#define MBEDTLS_MD_INFO_STARTS_FUNC( MD ) MBEDTLS_MD_INFO_STARTS_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_UPDATE_FUNC( MD ) MBEDTLS_MD_INFO_UPDATE_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_FINISH_FUNC( MD ) MBEDTLS_MD_INFO_FINISH_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_DIGEST_FUNC( MD ) MBEDTLS_MD_INFO_DIGEST_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_ALLOC_FUNC( MD ) MBEDTLS_MD_INFO_ALLOC_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_FREE_FUNC( MD ) MBEDTLS_MD_INFO_FREE_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_CLONE_FUNC( MD ) MBEDTLS_MD_INFO_CLONE_FUNC_T( MD ) -#define MBEDTLS_MD_INFO_PROCESS_FUNC( MD ) MBEDTLS_MD_INFO_PROCESS_FUNC_T( MD ) - -/** - * Message digest information. - * Allows message digest functions to be called in a generic way. - */ - -typedef int mbedtls_md_starts_func_t( void *ctx ); -typedef int mbedtls_md_update_func_t( void *ctx, - const unsigned char *input, - size_t ilen ); -typedef int mbedtls_md_finish_func_t( void *ctx, unsigned char *output ); -typedef int mbedtls_md_digest_func_t( const unsigned char *input, - size_t ilen, - unsigned char *output ); -typedef void* mbedtls_md_ctx_alloc_func_t( void ); -typedef void mbedtls_md_ctx_free_func_t( void *ctx ); -typedef void mbedtls_md_clone_func_t( void *st, const void *src ); -typedef int mbedtls_md_process_func_t( void *ctx, - const unsigned char *input ); - #if !defined(MBEDTLS_MD_SINGLE_HASH) -struct mbedtls_md_info_t -{ - /** Digest identifier */ - mbedtls_md_type_t type; - - /** Name of the message digest */ - const char * name; - - /** Output length of the digest function in bytes */ - int size; - - /** Block length of the digest function in bytes */ - int block_size; - - /** Digest initialisation function */ - mbedtls_md_starts_func_t *starts_func; - - /** Digest update function */ - mbedtls_md_update_func_t *update_func; - - /** Digest finalisation function */ - mbedtls_md_finish_func_t *finish_func; - - /** Generic digest function */ - mbedtls_md_digest_func_t *digest_func; - - /** Allocate a new context */ - mbedtls_md_ctx_alloc_func_t *ctx_alloc_func; - - /** Free the given context */ - mbedtls_md_ctx_free_func_t *ctx_free_func; - - /** Clone state from a context */ - mbedtls_md_clone_func_t *clone_func; - - /** Internal use only */ - mbedtls_md_process_func_t *process_func; -}; - -/** - * \brief This macro builds an instance of ::mbedtls_md_info_t - * from an \c MBEDTLS_MD_INFO_XXX identifier. - */ -#define MBEDTLS_MD_INFO( MD ) \ - { MBEDTLS_MD_INFO_TYPE( MD ), \ - MBEDTLS_MD_INFO_NAME( MD ), \ - MBEDTLS_MD_INFO_SIZE( MD ), \ - MBEDTLS_MD_INFO_BLOCKSIZE( MD ), \ - MBEDTLS_MD_INFO_STARTS_FUNC( MD ), \ - MBEDTLS_MD_INFO_UPDATE_FUNC( MD ), \ - MBEDTLS_MD_INFO_FINISH_FUNC( MD ), \ - MBEDTLS_MD_INFO_DIGEST_FUNC( MD ), \ - MBEDTLS_MD_INFO_ALLOC_FUNC( MD ), \ - MBEDTLS_MD_INFO_FREE_FUNC( MD ), \ - MBEDTLS_MD_INFO_CLONE_FUNC( MD ), \ - MBEDTLS_MD_INFO_PROCESS_FUNC( MD ) } - -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - /* * * Definitions of MD information structures for various digests. @@ -217,71 +58,21 @@ struct mbedtls_md_info_t /* * MD-2 */ - #if defined(MBEDTLS_MD2_C) - -static int md2_starts_wrap( void *ctx ) -{ - return( mbedtls_md2_starts_ret( (mbedtls_md2_context *) ctx ) ); -} - -static int md2_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_md2_update_ret( (mbedtls_md2_context *) ctx, input, ilen ) ); -} - -static int md2_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_md2_finish_ret( (mbedtls_md2_context *) ctx, output ) ); -} - -static void *md2_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md2_context ) ); - - if( ctx != NULL ) - mbedtls_md2_init( (mbedtls_md2_context *) ctx ); - - return( ctx ); -} - -static void md2_ctx_free( void *ctx ) -{ - mbedtls_md2_free( (mbedtls_md2_context *) ctx ); - mbedtls_free( ctx ); -} - -static void md2_clone_wrap( void *dst, const void *src ) -{ - mbedtls_md2_clone( (mbedtls_md2_context *) dst, - (const mbedtls_md2_context *) src ); -} - -static int md2_process_wrap( void *ctx, const unsigned char *data ) -{ - ((void) data); - - return( mbedtls_internal_md2_process( (mbedtls_md2_context *) ctx ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_md2_info = { MBEDTLS_MD_MD2, "MD2", 16, 16, - md2_starts_wrap, - md2_update_wrap, - md2_finish_wrap, + mbedtls_md2_starts_wrap, + mbedtls_md2_update_wrap, + mbedtls_md2_finish_wrap, mbedtls_md2_ret, - md2_ctx_alloc, - md2_ctx_free, - md2_clone_wrap, - md2_process_wrap, + mbedtls_md2_ctx_alloc, + mbedtls_md2_ctx_free, + mbedtls_md2_clone_wrap, + mbedtls_md2_process_wrap, }; -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_MD2_C */ /* @@ -289,67 +80,20 @@ const mbedtls_md_info_t mbedtls_md2_info = { */ #if defined(MBEDTLS_MD4_C) - -static int md4_starts_wrap( void *ctx ) -{ - return( mbedtls_md4_starts_ret( (mbedtls_md4_context *) ctx ) ); -} - -static int md4_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_md4_update_ret( (mbedtls_md4_context *) ctx, input, ilen ) ); -} - -static int md4_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_md4_finish_ret( (mbedtls_md4_context *) ctx, output ) ); -} - -static void *md4_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md4_context ) ); - - if( ctx != NULL ) - mbedtls_md4_init( (mbedtls_md4_context *) ctx ); - - return( ctx ); -} - -static void md4_ctx_free( void *ctx ) -{ - mbedtls_md4_free( (mbedtls_md4_context *) ctx ); - mbedtls_free( ctx ); -} - -static void md4_clone_wrap( void *dst, const void *src ) -{ - mbedtls_md4_clone( (mbedtls_md4_context *) dst, - (const mbedtls_md4_context *) src ); -} - -static int md4_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_md4_process( (mbedtls_md4_context *) ctx, data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_md4_info = { MBEDTLS_MD_MD4, "MD4", 16, 64, - md4_starts_wrap, - md4_update_wrap, - md4_finish_wrap, + mbedtls_md4_starts_wrap, + mbedtls_md4_update_wrap, + mbedtls_md4_finish_wrap, mbedtls_md4_ret, - md4_ctx_alloc, - md4_ctx_free, - md4_clone_wrap, - md4_process_wrap, + mbedtls_md4_ctx_alloc, + mbedtls_md4_ctx_free, + mbedtls_md4_clone_wrap, + mbedtls_md4_process_wrap, }; -#endif /* MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_MD4_C */ /* @@ -357,67 +101,20 @@ const mbedtls_md_info_t mbedtls_md4_info = { */ #if defined(MBEDTLS_MD5_C) - -static int md5_starts_wrap( void *ctx ) -{ - return( mbedtls_md5_starts_ret( (mbedtls_md5_context *) ctx ) ); -} - -static int md5_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_md5_update_ret( (mbedtls_md5_context *) ctx, input, ilen ) ); -} - -static int md5_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_md5_finish_ret( (mbedtls_md5_context *) ctx, output ) ); -} - -static void *md5_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_md5_context ) ); - - if( ctx != NULL ) - mbedtls_md5_init( (mbedtls_md5_context *) ctx ); - - return( ctx ); -} - -static void md5_ctx_free( void *ctx ) -{ - mbedtls_md5_free( (mbedtls_md5_context *) ctx ); - mbedtls_free( ctx ); -} - -static void md5_clone_wrap( void *dst, const void *src ) -{ - mbedtls_md5_clone( (mbedtls_md5_context *) dst, - (const mbedtls_md5_context *) src ); -} - -static int md5_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_md5_process( (mbedtls_md5_context *) ctx, data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_md5_info = { MBEDTLS_MD_MD5, "MD5", 16, 64, - md5_starts_wrap, - md5_update_wrap, - md5_finish_wrap, + mbedtls_md5_starts_wrap, + mbedtls_md5_update_wrap, + mbedtls_md5_finish_wrap, mbedtls_md5_ret, - md5_ctx_alloc, - md5_ctx_free, - md5_clone_wrap, - md5_process_wrap, + mbedtls_md5_ctx_alloc, + mbedtls_md5_ctx_free, + mbedtls_md5_clone_wrap, + mbedtls_md5_process_wrap, }; -#endif /* MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_MD5_C */ /* @@ -425,70 +122,20 @@ const mbedtls_md_info_t mbedtls_md5_info = { */ #if defined(MBEDTLS_RIPEMD160_C) - -static int ripemd160_starts_wrap( void *ctx ) -{ - return( mbedtls_ripemd160_starts_ret( (mbedtls_ripemd160_context *) ctx ) ); -} - -static int ripemd160_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_ripemd160_update_ret( (mbedtls_ripemd160_context *) ctx, - input, ilen ) ); -} - -static int ripemd160_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_ripemd160_finish_ret( (mbedtls_ripemd160_context *) ctx, - output ) ); -} - -static void *ripemd160_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_ripemd160_context ) ); - - if( ctx != NULL ) - mbedtls_ripemd160_init( (mbedtls_ripemd160_context *) ctx ); - - return( ctx ); -} - -static void ripemd160_ctx_free( void *ctx ) -{ - mbedtls_ripemd160_free( (mbedtls_ripemd160_context *) ctx ); - mbedtls_free( ctx ); -} - -static void ripemd160_clone_wrap( void *dst, const void *src ) -{ - mbedtls_ripemd160_clone( (mbedtls_ripemd160_context *) dst, - (const mbedtls_ripemd160_context *) src ); -} - -static int ripemd160_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_ripemd160_process( - (mbedtls_ripemd160_context *) ctx, data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_ripemd160_info = { MBEDTLS_MD_RIPEMD160, "RIPEMD160", 20, 64, - ripemd160_starts_wrap, - ripemd160_update_wrap, - ripemd160_finish_wrap, + mbedtls_ripemd160_starts_wrap, + mbedtls_ripemd160_update_wrap, + mbedtls_ripemd160_finish_wrap, mbedtls_ripemd160_ret, - ripemd160_ctx_alloc, - ripemd160_ctx_free, - ripemd160_clone_wrap, - ripemd160_process_wrap, + mbedtls_ripemd160_ctx_alloc, + mbedtls_ripemd160_ctx_free, + mbedtls_ripemd160_clone_wrap, + mbedtls_ripemd160_process_wrap, }; -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_RIPEMD160_C */ /* @@ -496,69 +143,20 @@ const mbedtls_md_info_t mbedtls_ripemd160_info = { */ #if defined(MBEDTLS_SHA1_C) - -static int sha1_starts_wrap( void *ctx ) -{ - return( mbedtls_sha1_starts_ret( (mbedtls_sha1_context *) ctx ) ); -} - -static int sha1_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_sha1_update_ret( (mbedtls_sha1_context *) ctx, - input, ilen ) ); -} - -static int sha1_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_sha1_finish_ret( (mbedtls_sha1_context *) ctx, output ) ); -} - -static void *sha1_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha1_context ) ); - - if( ctx != NULL ) - mbedtls_sha1_init( (mbedtls_sha1_context *) ctx ); - - return( ctx ); -} - -static void sha1_clone_wrap( void *dst, const void *src ) -{ - mbedtls_sha1_clone( (mbedtls_sha1_context *) dst, - (const mbedtls_sha1_context *) src ); -} - -static void sha1_ctx_free( void *ctx ) -{ - mbedtls_sha1_free( (mbedtls_sha1_context *) ctx ); - mbedtls_free( ctx ); -} - -static int sha1_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_sha1_process( (mbedtls_sha1_context *) ctx, - data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_sha1_info = { MBEDTLS_MD_SHA1, "SHA1", 20, 64, - sha1_starts_wrap, - sha1_update_wrap, - sha1_finish_wrap, + mbedtls_sha1_starts_wrap, + mbedtls_sha1_update_wrap, + mbedtls_sha1_finish_wrap, mbedtls_sha1_ret, - sha1_ctx_alloc, - sha1_ctx_free, - sha1_clone_wrap, - sha1_process_wrap, + mbedtls_sha1_ctx_alloc, + mbedtls_sha1_ctx_free, + mbedtls_sha1_clone_wrap, + mbedtls_sha1_process_wrap, }; -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_SHA1_C */ /* @@ -566,98 +164,24 @@ const mbedtls_md_info_t mbedtls_sha1_info = { */ #if defined(MBEDTLS_SHA256_C) - -#if !defined(MBEDTLS_SHA256_NO_SHA224) -static int sha224_starts_wrap( void *ctx ) -{ - return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 1 ) ); -} -#endif /* !MBEDTLS_SHA256_NO_SHA224 */ - -static int sha224_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_sha256_update_ret( (mbedtls_sha256_context *) ctx, - input, ilen ) ); -} - -static int sha224_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_sha256_finish_ret( (mbedtls_sha256_context *) ctx, - output ) ); -} - -#if !defined(MBEDTLS_SHA256_NO_SHA224) -static int sha224_wrap( const unsigned char *input, size_t ilen, - unsigned char *output ) -{ - return( mbedtls_sha256_ret( input, ilen, output, 1 ) ); -} -#endif /* !MBEDTLS_SHA256_NO_SHA224 */ - -static void *sha224_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha256_context ) ); - - if( ctx != NULL ) - mbedtls_sha256_init( (mbedtls_sha256_context *) ctx ); - - return( ctx ); -} - -static void sha224_ctx_free( void *ctx ) -{ - mbedtls_sha256_free( (mbedtls_sha256_context *) ctx ); - mbedtls_free( ctx ); -} - -static void sha224_clone_wrap( void *dst, const void *src ) -{ - mbedtls_sha256_clone( (mbedtls_sha256_context *) dst, - (const mbedtls_sha256_context *) src ); -} - -static int sha224_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_sha256_process( (mbedtls_sha256_context *) ctx, - data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) #if !defined(MBEDTLS_SHA256_NO_SHA224) const mbedtls_md_info_t mbedtls_sha224_info = { MBEDTLS_MD_SHA224, "SHA224", 28, 64, - sha224_starts_wrap, - sha224_update_wrap, - sha224_finish_wrap, - sha224_wrap, - sha224_ctx_alloc, - sha224_ctx_free, - sha224_clone_wrap, - sha224_process_wrap, + mbedtls_sha224_starts_wrap, + mbedtls_sha224_update_wrap, + mbedtls_sha224_finish_wrap, + mbedtls_sha224_wrap, + mbedtls_sha224_ctx_alloc, + mbedtls_sha224_ctx_free, + mbedtls_sha224_clone_wrap, + mbedtls_sha224_process_wrap, }; #endif /* !MBEDTLS_SHA256_NO_SHA224 */ -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - -static int sha256_starts_wrap( void *ctx ) -{ - return( mbedtls_sha256_starts_ret( (mbedtls_sha256_context *) ctx, 0 ) ); -} - -static int sha256_wrap( const unsigned char *input, size_t ilen, - unsigned char *output ) -{ - return( mbedtls_sha256_ret( input, ilen, output, 0 ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_sha256_info = MBEDTLS_MD_INFO( MBEDTLS_MD_INFO_SHA256 ); -#endif /* !MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_SHA256_C */ /* @@ -665,306 +189,36 @@ const mbedtls_md_info_t mbedtls_sha256_info = */ #if defined(MBEDTLS_SHA512_C) - -static int sha384_starts_wrap( void *ctx ) -{ - return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 1 ) ); -} - -static int sha384_update_wrap( void *ctx, const unsigned char *input, - size_t ilen ) -{ - return( mbedtls_sha512_update_ret( (mbedtls_sha512_context *) ctx, - input, ilen ) ); -} - -static int sha384_finish_wrap( void *ctx, unsigned char *output ) -{ - return( mbedtls_sha512_finish_ret( (mbedtls_sha512_context *) ctx, - output ) ); -} - -static int sha384_wrap( const unsigned char *input, size_t ilen, - unsigned char *output ) -{ - return( mbedtls_sha512_ret( input, ilen, output, 1 ) ); -} - -static void *sha384_ctx_alloc( void ) -{ - void *ctx = mbedtls_calloc( 1, sizeof( mbedtls_sha512_context ) ); - - if( ctx != NULL ) - mbedtls_sha512_init( (mbedtls_sha512_context *) ctx ); - - return( ctx ); -} - -static void sha384_ctx_free( void *ctx ) -{ - mbedtls_sha512_free( (mbedtls_sha512_context *) ctx ); - mbedtls_free( ctx ); -} - -static void sha384_clone_wrap( void *dst, const void *src ) -{ - mbedtls_sha512_clone( (mbedtls_sha512_context *) dst, - (const mbedtls_sha512_context *) src ); -} - -static int sha384_process_wrap( void *ctx, const unsigned char *data ) -{ - return( mbedtls_internal_sha512_process( (mbedtls_sha512_context *) ctx, - data ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_sha384_info = { MBEDTLS_MD_SHA384, "SHA384", 48, 128, - sha384_starts_wrap, - sha384_update_wrap, - sha384_finish_wrap, - sha384_wrap, - sha384_ctx_alloc, - sha384_ctx_free, - sha384_clone_wrap, - sha384_process_wrap, + mbedtls_sha384_starts_wrap, + mbedtls_sha384_update_wrap, + mbedtls_sha384_finish_wrap, + mbedtls_sha384_wrap, + mbedtls_sha384_ctx_alloc, + mbedtls_sha384_ctx_free, + mbedtls_sha384_clone_wrap, + mbedtls_sha384_process_wrap, }; -#endif /* MBEDTLS_MD_SINGLE_HASH */ - -static int sha512_starts_wrap( void *ctx ) -{ - return( mbedtls_sha512_starts_ret( (mbedtls_sha512_context *) ctx, 0 ) ); -} - -static int sha512_wrap( const unsigned char *input, size_t ilen, - unsigned char *output ) -{ - return( mbedtls_sha512_ret( input, ilen, output, 0 ) ); -} - -#if !defined(MBEDTLS_MD_SINGLE_HASH) const mbedtls_md_info_t mbedtls_sha512_info = { MBEDTLS_MD_SHA512, "SHA512", 64, 128, - sha512_starts_wrap, - sha384_update_wrap, - sha384_finish_wrap, - sha512_wrap, - sha384_ctx_alloc, - sha384_ctx_free, - sha384_clone_wrap, - sha384_process_wrap, + mbedtls_sha512_starts_wrap, + mbedtls_sha384_update_wrap, + mbedtls_sha384_finish_wrap, + mbedtls_sha512_wrap, + mbedtls_sha384_ctx_alloc, + mbedtls_sha384_ctx_free, + mbedtls_sha384_clone_wrap, + mbedtls_sha384_process_wrap, }; -#endif /* MBEDTLS_MD_SINGLE_HASH */ - #endif /* MBEDTLS_SHA512_C */ -/* - * Getter functions for MD info structure. - */ - -#if !defined(MBEDTLS_MD_SINGLE_HASH) - -MBEDTLS_ALWAYS_INLINE static inline mbedtls_md_type_t mbedtls_md_info_type( - mbedtls_md_handle_t info ) -{ - return( info->type ); -} - -MBEDTLS_ALWAYS_INLINE static inline const char * mbedtls_md_info_name( - mbedtls_md_handle_t info ) -{ - return( info->name ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_size( - mbedtls_md_handle_t info ) -{ - return( info->size ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_block_size( - mbedtls_md_handle_t info ) -{ - return( info->block_size ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_starts( - mbedtls_md_handle_t info, - void *ctx ) -{ - return( info->starts_func( ctx ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_update( - mbedtls_md_handle_t info, - void *ctx, - const unsigned char *input, - size_t ilen ) -{ - return( info->update_func( ctx, input, ilen ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_finish( - mbedtls_md_handle_t info, - void *ctx, - unsigned char *output ) -{ - return( info->finish_func( ctx, output ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_digest( - mbedtls_md_handle_t info, - const unsigned char *input, - size_t ilen, - unsigned char *output ) -{ - return( info->digest_func( input, ilen, output ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline void* mbedtls_md_info_ctx_alloc( - mbedtls_md_handle_t info ) -{ - return( info->ctx_alloc_func() ); -} - -MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_ctx_free( - mbedtls_md_handle_t info, - void *ctx ) -{ - info->ctx_free_func( ctx ); -} - -MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_clone( - mbedtls_md_handle_t info, - void *dst, - const void *src ) -{ - info->clone_func( dst, src ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_process( - mbedtls_md_handle_t info, - void *ctx, - const unsigned char *input ) -{ - return( info->process_func( ctx, input ) ); -} - -#else /* !MBEDTLS_MD_SINGLE_HASH */ - -MBEDTLS_ALWAYS_INLINE static inline mbedtls_md_type_t mbedtls_md_info_type( - mbedtls_md_handle_t info ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_TYPE( MBEDTLS_MD_SINGLE_HASH ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline const char * mbedtls_md_info_name( - mbedtls_md_handle_t info ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_NAME( MBEDTLS_MD_SINGLE_HASH ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_size( - mbedtls_md_handle_t info ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_SIZE( MBEDTLS_MD_SINGLE_HASH ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_block_size( - mbedtls_md_handle_t info ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_BLOCKSIZE( MBEDTLS_MD_SINGLE_HASH ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_starts( - mbedtls_md_handle_t info, - void *ctx ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_STARTS_FUNC( MBEDTLS_MD_SINGLE_HASH )( ctx ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_update( - mbedtls_md_handle_t info, - void *ctx, - const unsigned char *input, - size_t ilen ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_UPDATE_FUNC( MBEDTLS_MD_SINGLE_HASH ) - ( ctx, input, ilen ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_finish( - mbedtls_md_handle_t info, - void *ctx, - unsigned char *output ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_FINISH_FUNC( MBEDTLS_MD_SINGLE_HASH ) - ( ctx, output ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_digest( - mbedtls_md_handle_t info, - const unsigned char *input, - size_t ilen, - unsigned char *output ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_DIGEST_FUNC( MBEDTLS_MD_SINGLE_HASH ) - ( input, ilen, output ) ); -} - -MBEDTLS_ALWAYS_INLINE static inline void* mbedtls_md_info_ctx_alloc( - mbedtls_md_handle_t info ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_ALLOC_FUNC( MBEDTLS_MD_SINGLE_HASH )() ); -} - -MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_ctx_free( - mbedtls_md_handle_t info, - void *ctx ) -{ - ((void) info); - MBEDTLS_MD_INFO_FREE_FUNC( MBEDTLS_MD_SINGLE_HASH )( ctx ); -} - -MBEDTLS_ALWAYS_INLINE static inline void mbedtls_md_info_clone( - mbedtls_md_handle_t info, - void *dst, - const void *src ) -{ - ((void) info); - MBEDTLS_MD_INFO_CLONE_FUNC( MBEDTLS_MD_SINGLE_HASH )( dst, src ); -} - -MBEDTLS_ALWAYS_INLINE static inline int mbedtls_md_info_process( - mbedtls_md_handle_t info, - void *ctx, - const unsigned char *input ) -{ - ((void) info); - return( MBEDTLS_MD_INFO_PROCESS_FUNC( MBEDTLS_MD_SINGLE_HASH ) - ( ctx, input ) ); -} - -#endif /* MBEDTLS_MD_SINGLE_HASH */ - -#if !defined(MBEDTLS_MD_SINGLE_HASH) - /* * Reminder: update profiles in x509_crt.c when adding a new hash! */