2011-01-06 15:20:01 +01:00
|
|
|
/**
|
2015-04-08 12:49:31 +02:00
|
|
|
* \file mbedtls_md.c
|
2014-05-01 13:03:14 +02:00
|
|
|
*
|
2015-01-22 17:11:05 +01:00
|
|
|
* \brief Generic message digest wrapper for mbed TLS
|
2011-01-06 15:20:01 +01:00
|
|
|
*
|
|
|
|
|
* \author Adriaan de Jong <dejong@fox-it.com>
|
|
|
|
|
*
|
2015-07-27 11:11:48 +02:00
|
|
|
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
|
2015-09-04 14:21:07 +02:00
|
|
|
* SPDX-License-Identifier: Apache-2.0
|
2011-01-06 15:20:01 +01:00
|
|
|
*
|
2015-09-04 14:21:07 +02:00
|
|
|
* 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
|
2011-01-06 15:20:01 +01:00
|
|
|
*
|
2015-09-04 14:21:07 +02:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2011-01-06 15:20:01 +01:00
|
|
|
*
|
2015-09-04 14:21:07 +02:00
|
|
|
* 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.
|
2011-01-06 15:20:01 +01:00
|
|
|
*
|
2015-09-04 14:21:07 +02:00
|
|
|
* This file is part of mbed TLS (https://tls.mbed.org)
|
2011-01-06 15:20:01 +01:00
|
|
|
*/
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if !defined(MBEDTLS_CONFIG_FILE)
|
2015-03-09 18:05:11 +01:00
|
|
|
#include "mbedtls/config.h"
|
2014-04-29 12:39:06 +02:00
|
|
|
#else
|
2015-04-08 12:49:31 +02:00
|
|
|
#include MBEDTLS_CONFIG_FILE
|
2014-04-29 12:39:06 +02:00
|
|
|
#endif
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD_C)
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-03-09 18:05:11 +01:00
|
|
|
#include "mbedtls/md.h"
|
2018-04-17 16:51:09 +02:00
|
|
|
#include "mbedtls/platform_util.h"
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_PLATFORM_C)
|
2015-03-25 11:49:07 +01:00
|
|
|
#include "mbedtls/platform.h"
|
|
|
|
|
#else
|
2011-01-06 15:20:01 +01:00
|
|
|
#include <stdlib.h>
|
2015-05-26 16:04:06 +02:00
|
|
|
#define mbedtls_calloc calloc
|
2015-04-08 12:49:31 +02:00
|
|
|
#define mbedtls_free free
|
2015-03-25 11:49:07 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-02-06 14:43:58 +01:00
|
|
|
#include <string.h>
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-05-28 14:44:00 +02:00
|
|
|
#if defined(MBEDTLS_FS_IO)
|
|
|
|
|
#include <stdio.h>
|
2011-04-18 05:47:52 +02:00
|
|
|
#endif
|
|
|
|
|
|
Add config.h option to hardcode choice of single MD algorithm
This commit introduces the configuration option
MBEDTLS_MD_SINGLE_HASH
which can be used to hardcode support for a single digest algorithm
at compile-time, at the benefit of reduced code-size.
To use, it needs to be defined to evaluate to a macro of the form
MBEDTLS_MD_INFO_{DIGEST}, and macros MBEDTLS_MD_INFO_{DIGEST}_FIELD
must be defined, giving rise to the various aspects (name, type,
size, ...) of the chosen digest algorithm. MBEDTLS_MD_INFO_SHA256
provides an example, but other algorithms can be added if needed.
At the moment, the effect of using MBEDTLS_MD_SINGLE_HASH is that
the implementation of the MD API (e.g. mbedtls_md_update()) need no
longer to through the abstraction of the mbedtls_md_info structures
by calling their corresponding function pointers fields (akin to
virtual functions in C++), but the directly call the corresponding
core digest function (such as mbedtls_sha256_update()).
Therefore, MBEDTLS_MD_SINGLE_HASH so far removes the second layer
of indirection in the chain
User calls MD API -> MD API calls underlying digest impl'n
-> Core digest impl'n does the actual work,
but the first indirection remains, as the MD API remains untouched
and cannot yet be inlined. Studying to what extend inlining the
shortened MD API implementations would lead to further code-savings
is left for a later commit.
2019-08-13 16:43:26 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
2019-07-26 15:38:44 +02:00
|
|
|
/*
|
|
|
|
|
*
|
|
|
|
|
* Definitions of MD information structures for various digests.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MD-2
|
|
|
|
|
*/
|
|
|
|
|
#if defined(MBEDTLS_MD2_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_md2_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_MD2,
|
|
|
|
|
"MD2",
|
|
|
|
|
16,
|
|
|
|
|
16,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md2_starts_wrap,
|
|
|
|
|
mbedtls_md2_update_wrap,
|
|
|
|
|
mbedtls_md2_finish_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
mbedtls_md2_ret,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md2_ctx_alloc,
|
|
|
|
|
mbedtls_md2_ctx_free,
|
|
|
|
|
mbedtls_md2_clone_wrap,
|
|
|
|
|
mbedtls_md2_process_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_MD2_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MD-4
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_MD4_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_md4_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_MD4,
|
|
|
|
|
"MD4",
|
|
|
|
|
16,
|
|
|
|
|
64,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md4_starts_wrap,
|
|
|
|
|
mbedtls_md4_update_wrap,
|
|
|
|
|
mbedtls_md4_finish_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
mbedtls_md4_ret,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md4_ctx_alloc,
|
|
|
|
|
mbedtls_md4_ctx_free,
|
|
|
|
|
mbedtls_md4_clone_wrap,
|
|
|
|
|
mbedtls_md4_process_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_MD4_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* MD-5
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_MD5_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_md5_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_MD5,
|
|
|
|
|
"MD5",
|
|
|
|
|
16,
|
|
|
|
|
64,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md5_starts_wrap,
|
|
|
|
|
mbedtls_md5_update_wrap,
|
|
|
|
|
mbedtls_md5_finish_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
mbedtls_md5_ret,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_md5_ctx_alloc,
|
|
|
|
|
mbedtls_md5_ctx_free,
|
|
|
|
|
mbedtls_md5_clone_wrap,
|
|
|
|
|
mbedtls_md5_process_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_MD5_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* RIPEMD-160
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_RIPEMD160_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_ripemd160_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_RIPEMD160,
|
|
|
|
|
"RIPEMD160",
|
|
|
|
|
20,
|
|
|
|
|
64,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_ripemd160_starts_wrap,
|
|
|
|
|
mbedtls_ripemd160_update_wrap,
|
|
|
|
|
mbedtls_ripemd160_finish_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
mbedtls_ripemd160_ret,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_ripemd160_ctx_alloc,
|
|
|
|
|
mbedtls_ripemd160_ctx_free,
|
|
|
|
|
mbedtls_ripemd160_clone_wrap,
|
|
|
|
|
mbedtls_ripemd160_process_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_RIPEMD160_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* SHA-1
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_SHA1_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_sha1_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_SHA1,
|
|
|
|
|
"SHA1",
|
|
|
|
|
20,
|
|
|
|
|
64,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_sha1_starts_wrap,
|
|
|
|
|
mbedtls_sha1_update_wrap,
|
|
|
|
|
mbedtls_sha1_finish_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
mbedtls_sha1_ret,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
mbedtls_sha1_ctx_alloc,
|
|
|
|
|
mbedtls_sha1_ctx_free,
|
|
|
|
|
mbedtls_sha1_clone_wrap,
|
|
|
|
|
mbedtls_sha1_process_wrap,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_SHA1_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* SHA-224 and SHA-256
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_SHA256_C)
|
|
|
|
|
#if !defined(MBEDTLS_SHA256_NO_SHA224)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_sha224_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_SHA224,
|
|
|
|
|
"SHA224",
|
|
|
|
|
28,
|
|
|
|
|
64,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
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,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* !MBEDTLS_SHA256_NO_SHA224 */
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_sha256_info =
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_INFO( MBEDTLS_MD_INFO_SHA256 );
|
|
|
|
|
#endif /* MBEDTLS_SHA256_C */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* SHA-384 and SHA-512
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_SHA512_C)
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_sha384_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_SHA384,
|
|
|
|
|
"SHA384",
|
|
|
|
|
48,
|
|
|
|
|
128,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
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,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
2019-09-04 16:14:51 +02:00
|
|
|
static const mbedtls_md_info_t mbedtls_sha512_info = {
|
2019-07-26 15:38:44 +02:00
|
|
|
MBEDTLS_MD_SHA512,
|
|
|
|
|
"SHA512",
|
|
|
|
|
64,
|
|
|
|
|
128,
|
Introduce md_internal.h
Recall that in the default configuration, Mbed TLS provides access
digest implementations through two layers of indirection:
1) Call of MD API (e.g. mbedtls_md_update())
2) Call of function pointer from MD info structure
3) Actual digest implementation (e.g. mbedtls_sha256_update()).
Ideally, if only a single digest is enabled - say SHA-256 - then calling
mbedtls_md_update() should _directly_ jump to mbedtls_sha256_update(),
with both layers of indirection removed. So far, however, setting
MBEDTLS_MD_SINGLE_HASH will only remove the second - function pointer -
layer of indirection, while keeping the non-inlined stub implementations
of e.g. mbedtls_md_update() around.
This commit is a step towards allowing to define implementations of
the MD API as `static inline` in case we know that they are so small
that they should be defined in md.h and not in md.c.
In a nutshell, the approach is as follows: For an MD API function
mbedtls_md_xxx() that should be inlin-able, introduce its implementation
as a `static inline` wrapper `mbedtls_md_xxx_internal()` in md.h,
and then define mbedtls_md_xxx() either in md.h or in md.c, by just
calling mbedtls_md_xxx_internal().
Moving the implementations of those MD API functions that should be
inlinable to md.h requires the presence of both the MD info struct
and all specific digest wrapper functions in md.h, and this is what
this commit ensures, by moving them from md.c into a new internal
header file md_internal.h. Implementing the aforementioned wrappers for
those MD API that should be inlinable is left for subsequent commits.
2019-09-04 13:43:22 +02:00
|
|
|
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,
|
2019-07-26 15:38:44 +02:00
|
|
|
};
|
|
|
|
|
#endif /* MBEDTLS_SHA512_C */
|
|
|
|
|
|
2015-06-15 14:34:59 +02:00
|
|
|
/*
|
|
|
|
|
* Reminder: update profiles in x509_crt.c when adding a new hash!
|
|
|
|
|
*/
|
2011-01-16 22:27:44 +01:00
|
|
|
static const int supported_digests[] = {
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA512_C)
|
|
|
|
|
MBEDTLS_MD_SHA512,
|
|
|
|
|
MBEDTLS_MD_SHA384,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA256_C)
|
|
|
|
|
MBEDTLS_MD_SHA256,
|
2019-07-16 15:57:36 +02:00
|
|
|
#if !defined(MBEDTLS_SHA256_NO_SHA224)
|
2015-04-08 12:49:31 +02:00
|
|
|
MBEDTLS_MD_SHA224,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
2019-07-16 15:57:36 +02:00
|
|
|
#endif /* MBEDTLS_SHA256_C */
|
2011-01-16 22:27:44 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA1_C)
|
|
|
|
|
MBEDTLS_MD_SHA1,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_RIPEMD160_C)
|
|
|
|
|
MBEDTLS_MD_RIPEMD160,
|
2014-01-17 20:41:32 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD5_C)
|
|
|
|
|
MBEDTLS_MD_MD5,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD4_C)
|
|
|
|
|
MBEDTLS_MD_MD4,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD2_C)
|
|
|
|
|
MBEDTLS_MD_MD2,
|
2011-01-16 22:27:44 +01:00
|
|
|
#endif
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
MBEDTLS_MD_NONE
|
2011-01-16 22:27:44 +01:00
|
|
|
};
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
const int *mbedtls_md_list( void )
|
2011-01-16 22:27:44 +01:00
|
|
|
{
|
2014-06-17 14:06:49 +02:00
|
|
|
return( supported_digests );
|
2011-01-16 22:27:44 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
mbedtls_md_handle_t mbedtls_md_info_from_string( const char *md_name )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
|
|
|
|
if( NULL == md_name )
|
2014-06-17 14:06:49 +02:00
|
|
|
return( NULL );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
|
|
|
|
/* Get the appropriate digest information */
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD2_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "MD2", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_MD2 );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD4_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "MD4", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_MD4 );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD5_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "MD5", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_RIPEMD160_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "RIPEMD160", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
|
2014-01-17 20:41:32 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA1_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "SHA1", md_name ) || !strcmp( "SHA", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA256_C)
|
2019-07-16 15:57:36 +02:00
|
|
|
#if !defined(MBEDTLS_SHA256_NO_SHA224)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "SHA224", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
|
2019-07-16 15:57:36 +02:00
|
|
|
#endif
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "SHA256", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
|
2019-07-16 15:57:36 +02:00
|
|
|
#endif /* MBEDTLS_SHA256_C */
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA512_C)
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "SHA384", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
|
2015-05-28 17:06:07 +02:00
|
|
|
if( !strcmp( "SHA512", md_name ) )
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2014-06-17 14:06:49 +02:00
|
|
|
return( NULL );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
mbedtls_md_handle_t mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
|
|
|
|
switch( md_type )
|
|
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD2_C)
|
|
|
|
|
case MBEDTLS_MD_MD2:
|
|
|
|
|
return( &mbedtls_md2_info );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD4_C)
|
|
|
|
|
case MBEDTLS_MD_MD4:
|
|
|
|
|
return( &mbedtls_md4_info );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_MD5_C)
|
|
|
|
|
case MBEDTLS_MD_MD5:
|
|
|
|
|
return( &mbedtls_md5_info );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_RIPEMD160_C)
|
|
|
|
|
case MBEDTLS_MD_RIPEMD160:
|
|
|
|
|
return( &mbedtls_ripemd160_info );
|
2014-01-17 20:41:32 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA1_C)
|
|
|
|
|
case MBEDTLS_MD_SHA1:
|
|
|
|
|
return( &mbedtls_sha1_info );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA256_C)
|
2019-07-16 15:57:36 +02:00
|
|
|
#if !defined(MBEDTLS_SHA256_NO_SHA224)
|
2015-04-08 12:49:31 +02:00
|
|
|
case MBEDTLS_MD_SHA224:
|
|
|
|
|
return( &mbedtls_sha224_info );
|
2019-07-16 15:57:36 +02:00
|
|
|
#endif
|
2015-04-08 12:49:31 +02:00
|
|
|
case MBEDTLS_MD_SHA256:
|
|
|
|
|
return( &mbedtls_sha256_info );
|
2019-07-16 15:57:36 +02:00
|
|
|
#endif /* MBEDTLS_SHA256_C */
|
2015-04-08 12:49:31 +02:00
|
|
|
#if defined(MBEDTLS_SHA512_C)
|
|
|
|
|
case MBEDTLS_MD_SHA384:
|
|
|
|
|
return( &mbedtls_sha384_info );
|
|
|
|
|
case MBEDTLS_MD_SHA512:
|
|
|
|
|
return( &mbedtls_sha512_info );
|
2011-01-06 15:20:01 +01:00
|
|
|
#endif
|
|
|
|
|
default:
|
2014-06-17 14:06:49 +02:00
|
|
|
return( NULL );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
Add config.h option to hardcode choice of single MD algorithm
This commit introduces the configuration option
MBEDTLS_MD_SINGLE_HASH
which can be used to hardcode support for a single digest algorithm
at compile-time, at the benefit of reduced code-size.
To use, it needs to be defined to evaluate to a macro of the form
MBEDTLS_MD_INFO_{DIGEST}, and macros MBEDTLS_MD_INFO_{DIGEST}_FIELD
must be defined, giving rise to the various aspects (name, type,
size, ...) of the chosen digest algorithm. MBEDTLS_MD_INFO_SHA256
provides an example, but other algorithms can be added if needed.
At the moment, the effect of using MBEDTLS_MD_SINGLE_HASH is that
the implementation of the MD API (e.g. mbedtls_md_update()) need no
longer to through the abstraction of the mbedtls_md_info structures
by calling their corresponding function pointers fields (akin to
virtual functions in C++), but the directly call the corresponding
core digest function (such as mbedtls_sha256_update()).
Therefore, MBEDTLS_MD_SINGLE_HASH so far removes the second layer
of indirection in the chain
User calls MD API -> MD API calls underlying digest impl'n
-> Core digest impl'n does the actual work,
but the first indirection remains, as the MD API remains untouched
and cannot yet be inlined. Studying to what extend inlining the
shortened MD API implementations would lead to further code-savings
is left for a later commit.
2019-08-13 16:43:26 +02:00
|
|
|
#else /* MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
|
|
|
|
const int *mbedtls_md_list( void )
|
|
|
|
|
{
|
|
|
|
|
static int single_hash[2] =
|
|
|
|
|
{ MBEDTLS_MD_INFO_TYPE( MBEDTLS_MD_SINGLE_HASH ),
|
|
|
|
|
MBEDTLS_MD_INVALID_HANDLE };
|
|
|
|
|
|
|
|
|
|
return( single_hash );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mbedtls_md_handle_t mbedtls_md_info_from_string( const char *md_name )
|
|
|
|
|
{
|
|
|
|
|
static const char * const hash_name =
|
|
|
|
|
MBEDTLS_MD_INFO_NAME( MBEDTLS_MD_SINGLE_HASH );
|
|
|
|
|
|
|
|
|
|
if( md_name != NULL && strcmp( hash_name, md_name ) == 0 )
|
|
|
|
|
return( MBEDTLS_MD_UNIQUE_VALID_HANDLE );
|
|
|
|
|
|
|
|
|
|
return( MBEDTLS_MD_INVALID_HANDLE );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
mbedtls_md_handle_t mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
|
|
|
|
|
{
|
|
|
|
|
static const mbedtls_md_type_t hash_type =
|
|
|
|
|
MBEDTLS_MD_INFO_TYPE( MBEDTLS_MD_SINGLE_HASH );
|
|
|
|
|
|
|
|
|
|
if( hash_type == md_type )
|
|
|
|
|
return( MBEDTLS_MD_UNIQUE_VALID_HANDLE );
|
|
|
|
|
|
|
|
|
|
return( MBEDTLS_MD_INVALID_HANDLE );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
void mbedtls_md_init( mbedtls_md_context_t *ctx )
|
2014-07-01 14:53:22 +02:00
|
|
|
{
|
2019-10-03 10:40:57 +02:00
|
|
|
memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
|
2019-09-05 14:02:52 +02:00
|
|
|
|
|
|
|
|
#if defined(MBEDTLS_MD_SINGLE_HASH)
|
|
|
|
|
mbedtls_md_info_init( mbedtls_md_get_handle( ctx ),
|
|
|
|
|
ctx->md_ctx );
|
|
|
|
|
#endif
|
2014-07-01 14:53:22 +02:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
void mbedtls_md_free( mbedtls_md_context_t *ctx )
|
2014-07-01 14:53:22 +02:00
|
|
|
{
|
2019-09-03 13:56:37 +02:00
|
|
|
if( ctx == NULL || mbedtls_md_get_handle( ctx ) == MBEDTLS_MD_INVALID_HANDLE )
|
2014-07-01 14:53:22 +02:00
|
|
|
return;
|
|
|
|
|
|
2019-09-05 14:02:52 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
2015-03-25 11:49:07 +01:00
|
|
|
if( ctx->md_ctx != NULL )
|
2019-09-03 13:56:37 +02:00
|
|
|
{
|
2019-09-04 12:15:02 +02:00
|
|
|
mbedtls_md_info_ctx_free( mbedtls_md_get_handle( ctx ), ctx->md_ctx );
|
2019-09-03 13:56:37 +02:00
|
|
|
}
|
2014-07-01 14:53:22 +02:00
|
|
|
|
2015-03-25 11:49:07 +01:00
|
|
|
if( ctx->hmac_ctx != NULL )
|
|
|
|
|
{
|
2018-04-17 16:51:09 +02:00
|
|
|
mbedtls_platform_zeroize( ctx->hmac_ctx,
|
2019-09-03 13:56:37 +02:00
|
|
|
2 * mbedtls_md_info_block_size( mbedtls_md_get_handle( ctx ) ) );
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_free( ctx->hmac_ctx );
|
2015-03-25 11:49:07 +01:00
|
|
|
}
|
2019-09-05 14:02:52 +02:00
|
|
|
#endif /* MBEDTLS_MD_SINGLE_HASH */
|
2015-03-25 11:49:07 +01:00
|
|
|
|
2018-04-17 16:51:09 +02:00
|
|
|
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
|
2014-07-01 14:53:22 +02:00
|
|
|
}
|
|
|
|
|
|
2015-07-06 16:06:02 +02:00
|
|
|
int mbedtls_md_clone( mbedtls_md_context_t *dst,
|
|
|
|
|
const mbedtls_md_context_t *src )
|
|
|
|
|
{
|
2019-09-03 13:56:37 +02:00
|
|
|
if( dst == NULL || mbedtls_md_get_handle( dst ) == MBEDTLS_MD_INVALID_HANDLE ||
|
|
|
|
|
src == NULL || mbedtls_md_get_handle( src ) == MBEDTLS_MD_INVALID_HANDLE ||
|
|
|
|
|
mbedtls_md_get_handle( dst ) != mbedtls_md_get_handle( src ) )
|
2015-07-06 16:06:02 +02:00
|
|
|
{
|
|
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
mbedtls_md_info_clone( mbedtls_md_get_handle( dst ),
|
|
|
|
|
dst->md_ctx, src->md_ctx );
|
2015-07-06 16:06:02 +02:00
|
|
|
return( 0 );
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#if ! defined(MBEDTLS_DEPRECATED_REMOVED)
|
2019-07-17 12:21:02 +02:00
|
|
|
int mbedtls_md_init_ctx( mbedtls_md_context_t *ctx, mbedtls_md_handle_t md_info )
|
2015-03-25 16:43:14 +01:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
return mbedtls_md_setup( ctx, md_info, 1 );
|
2015-03-25 16:43:14 +01:00
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2019-09-05 14:02:32 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
2019-07-17 12:21:02 +02:00
|
|
|
int mbedtls_md_setup( mbedtls_md_context_t *ctx, mbedtls_md_handle_t md_info, int hmac )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2019-09-05 14:02:32 +02:00
|
|
|
return( mbedtls_md_setup_internal( ctx, md_info, hmac ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_starts( mbedtls_md_context_t *ctx )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2019-09-04 13:46:07 +02:00
|
|
|
return( mbedtls_md_starts_internal( ctx ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-09-04 14:20:05 +02:00
|
|
|
int mbedtls_md_update( mbedtls_md_context_t *ctx,
|
|
|
|
|
const unsigned char *input,
|
|
|
|
|
size_t ilen )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2019-09-04 14:20:05 +02:00
|
|
|
return( mbedtls_md_update_internal( ctx, input, ilen ) );
|
2011-01-20 17:42:01 +01:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
|
2011-01-20 17:42:01 +01:00
|
|
|
{
|
2019-09-04 14:24:44 +02:00
|
|
|
return( mbedtls_md_finish_internal( ctx, output ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
int mbedtls_md( mbedtls_md_handle_t md_info, const unsigned char *input, size_t ilen,
|
2011-01-06 15:20:01 +01:00
|
|
|
unsigned char *output )
|
|
|
|
|
{
|
2019-09-04 14:24:44 +02:00
|
|
|
return( mbedtls_md_internal( md_info, input, ilen, output ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
2019-09-04 14:24:44 +02:00
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-05-28 14:44:00 +02:00
|
|
|
#if defined(MBEDTLS_FS_IO)
|
2019-07-17 12:21:02 +02:00
|
|
|
int mbedtls_md_file( mbedtls_md_handle_t md_info, const char *path, unsigned char *output )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2011-06-09 17:55:11 +02:00
|
|
|
int ret;
|
2015-05-28 14:44:00 +02:00
|
|
|
FILE *f;
|
|
|
|
|
size_t n;
|
|
|
|
|
mbedtls_md_context_t ctx;
|
|
|
|
|
unsigned char buf[1024];
|
2011-06-09 17:55:11 +02:00
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-05-28 14:44:00 +02:00
|
|
|
if( ( f = fopen( path, "rb" ) ) == NULL )
|
2015-06-24 00:09:29 +02:00
|
|
|
return( MBEDTLS_ERR_MD_FILE_IO_ERROR );
|
|
|
|
|
|
|
|
|
|
mbedtls_md_init( &ctx );
|
2011-04-25 17:28:35 +02:00
|
|
|
|
2015-05-28 14:44:00 +02:00
|
|
|
if( ( ret = mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
|
|
|
|
|
goto cleanup;
|
|
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
ret = mbedtls_md_info_starts( md_info, ctx.md_ctx );
|
2019-07-17 15:10:26 +02:00
|
|
|
if( ret != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2015-05-28 14:44:00 +02:00
|
|
|
|
|
|
|
|
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
|
2019-07-17 15:10:26 +02:00
|
|
|
{
|
2019-09-04 12:15:02 +02:00
|
|
|
ret = mbedtls_md_info_update( md_info, ctx.md_ctx,
|
|
|
|
|
buf, n );
|
2019-07-17 15:10:26 +02:00
|
|
|
if( ret != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2019-07-17 15:10:26 +02:00
|
|
|
}
|
2015-05-28 14:44:00 +02:00
|
|
|
|
|
|
|
|
if( ferror( f ) != 0 )
|
2019-07-17 15:10:26 +02:00
|
|
|
{
|
2015-05-28 14:44:00 +02:00
|
|
|
ret = MBEDTLS_ERR_MD_FILE_IO_ERROR;
|
2019-07-17 15:10:26 +02:00
|
|
|
}
|
2017-06-23 17:30:31 +02:00
|
|
|
else
|
2019-07-17 15:10:26 +02:00
|
|
|
{
|
2019-09-04 12:15:02 +02:00
|
|
|
ret = mbedtls_md_info_finish( md_info, ctx.md_ctx,
|
|
|
|
|
output );
|
2019-07-17 15:10:26 +02:00
|
|
|
}
|
2015-05-28 14:44:00 +02:00
|
|
|
|
|
|
|
|
cleanup:
|
2018-04-17 16:51:09 +02:00
|
|
|
mbedtls_platform_zeroize( buf, sizeof( buf ) );
|
2015-05-28 14:44:00 +02:00
|
|
|
fclose( f );
|
|
|
|
|
mbedtls_md_free( &ctx );
|
|
|
|
|
|
|
|
|
|
return( ret );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
2015-05-28 14:44:00 +02:00
|
|
|
#endif /* MBEDTLS_FS_IO */
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
int ret;
|
2015-04-08 12:49:31 +02:00
|
|
|
unsigned char sum[MBEDTLS_MD_MAX_SIZE];
|
2015-03-25 11:49:07 +01:00
|
|
|
unsigned char *ipad, *opad;
|
2015-03-24 16:48:22 +01:00
|
|
|
size_t i;
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_handle_t md_info;
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
if( ctx == NULL )
|
2019-09-03 13:56:37 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
|
|
|
|
if( ctx->hmac_ctx == NULL )
|
|
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
md_info = mbedtls_md_get_handle( ctx );
|
|
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
if( keylen > (size_t) mbedtls_md_info_block_size( md_info ) )
|
2015-03-24 16:48:22 +01:00
|
|
|
{
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_starts( md_info, ctx->md_ctx ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_update( md_info, ctx->md_ctx,
|
|
|
|
|
key, keylen ) ) != 0 )
|
|
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2019-09-04 12:15:02 +02:00
|
|
|
}
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_finish( md_info, ctx->md_ctx, sum ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
keylen = mbedtls_md_info_size( md_info );
|
2015-03-24 16:48:22 +01:00
|
|
|
key = sum;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-25 11:49:07 +01:00
|
|
|
ipad = (unsigned char *) ctx->hmac_ctx;
|
2019-09-03 13:56:37 +02:00
|
|
|
opad = (unsigned char *) ctx->hmac_ctx +
|
|
|
|
|
mbedtls_md_info_block_size( md_info );
|
2015-03-25 11:49:07 +01:00
|
|
|
|
2019-10-02 14:47:01 +02:00
|
|
|
mbedtls_platform_memset( ipad, 0x36, mbedtls_md_info_block_size( md_info ) );
|
|
|
|
|
mbedtls_platform_memset( opad, 0x5C, mbedtls_md_info_block_size( md_info ) );
|
2015-03-24 16:48:22 +01:00
|
|
|
|
|
|
|
|
for( i = 0; i < keylen; i++ )
|
|
|
|
|
{
|
2015-03-25 11:49:07 +01:00
|
|
|
ipad[i] = (unsigned char)( ipad[i] ^ key[i] );
|
|
|
|
|
opad[i] = (unsigned char)( opad[i] ^ key[i] );
|
2015-03-24 16:48:22 +01:00
|
|
|
}
|
|
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_starts( md_info, ctx->md_ctx ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_update( md_info, ctx->md_ctx, ipad,
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_info_block_size( md_info ) ) ) != 0 )
|
|
|
|
|
{
|
2017-07-20 17:27:03 +02:00
|
|
|
goto cleanup;
|
2019-09-03 13:56:37 +02:00
|
|
|
}
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2017-06-28 15:16:07 +02:00
|
|
|
cleanup:
|
2018-04-17 16:51:09 +02:00
|
|
|
mbedtls_platform_zeroize( sum, sizeof( sum ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx,
|
|
|
|
|
const unsigned char *input, size_t ilen )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_handle_t md_info;
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
if( ctx == NULL )
|
2019-09-03 13:56:37 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
|
|
|
|
if( ctx->hmac_ctx == NULL )
|
|
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
md_info = mbedtls_md_get_handle( ctx );
|
|
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
return( mbedtls_md_info_update( md_info,
|
|
|
|
|
ctx->md_ctx, input,
|
|
|
|
|
ilen ) );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
int ret;
|
2015-04-08 12:49:31 +02:00
|
|
|
unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
|
2015-03-25 11:49:07 +01:00
|
|
|
unsigned char *opad;
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_handle_t md_info;
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
if( ctx == NULL )
|
2019-09-03 13:56:37 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
|
|
|
|
if( ctx->hmac_ctx == NULL )
|
|
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
md_info = mbedtls_md_get_handle( ctx );
|
|
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
opad = (unsigned char *) ctx->hmac_ctx +
|
|
|
|
|
mbedtls_md_info_block_size( md_info );
|
2015-03-25 11:49:07 +01:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_finish( md_info, ctx->md_ctx, tmp ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_starts( md_info, ctx->md_ctx ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_update( md_info, ctx->md_ctx, opad,
|
|
|
|
|
mbedtls_md_info_block_size( md_info ) ) ) != 0 )
|
2019-09-03 13:56:37 +02:00
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2019-09-03 13:56:37 +02:00
|
|
|
}
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_update( md_info, ctx->md_ctx, tmp,
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_info_size( md_info ) ) ) != 0 )
|
|
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2019-09-03 13:56:37 +02:00
|
|
|
}
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
if( ( ret = mbedtls_md_info_finish( md_info, ctx->md_ctx, output ) ) != 0 )
|
2019-07-17 15:10:26 +02:00
|
|
|
return( ret );
|
|
|
|
|
|
|
|
|
|
return( 0 );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2017-06-28 15:16:07 +02:00
|
|
|
int ret;
|
2015-03-25 11:49:07 +01:00
|
|
|
unsigned char *ipad;
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
mbedtls_md_handle_t md_info;
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
if( ctx == NULL )
|
2019-09-03 13:56:37 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
|
2019-09-05 16:03:56 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
|
|
|
|
if( ctx->hmac_ctx == NULL )
|
|
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
|
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
|
|
|
|
|
2019-09-03 13:56:37 +02:00
|
|
|
md_info = mbedtls_md_get_handle( ctx );
|
|
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-03-25 11:49:07 +01:00
|
|
|
ipad = (unsigned char *) ctx->hmac_ctx;
|
|
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
ret = mbedtls_md_info_starts( md_info, ctx->md_ctx );
|
2019-07-17 15:10:26 +02:00
|
|
|
if( ret != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2019-07-17 15:10:26 +02:00
|
|
|
|
2019-09-04 12:15:02 +02:00
|
|
|
ret = mbedtls_md_info_update( md_info,
|
|
|
|
|
ctx->md_ctx, ipad,
|
|
|
|
|
mbedtls_md_info_block_size( md_info ) );
|
2019-07-17 15:10:26 +02:00
|
|
|
return( ret );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
int mbedtls_md_hmac( mbedtls_md_handle_t md_info,
|
2017-06-28 15:16:07 +02:00
|
|
|
const unsigned char *key, size_t keylen,
|
|
|
|
|
const unsigned char *input, size_t ilen,
|
|
|
|
|
unsigned char *output )
|
2011-01-06 15:20:01 +01:00
|
|
|
{
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_md_context_t ctx;
|
2015-03-24 16:48:22 +01:00
|
|
|
int ret;
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_md_init( &ctx );
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
if( ( ret = mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
|
2017-06-28 15:16:07 +02:00
|
|
|
goto cleanup;
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2017-06-28 15:16:07 +02:00
|
|
|
if( ( ret = mbedtls_md_hmac_starts( &ctx, key, keylen ) ) != 0 )
|
|
|
|
|
goto cleanup;
|
|
|
|
|
if( ( ret = mbedtls_md_hmac_update( &ctx, input, ilen ) ) != 0 )
|
|
|
|
|
goto cleanup;
|
2017-07-21 15:21:53 +02:00
|
|
|
if( ( ret = mbedtls_md_hmac_finish( &ctx, output ) ) != 0 )
|
|
|
|
|
goto cleanup;
|
2015-03-24 16:48:22 +01:00
|
|
|
|
2017-06-28 15:16:07 +02:00
|
|
|
cleanup:
|
2015-04-08 12:49:31 +02:00
|
|
|
mbedtls_md_free( &ctx );
|
2011-01-06 15:20:01 +01:00
|
|
|
|
2017-06-28 15:16:07 +02:00
|
|
|
return( ret );
|
2011-01-06 15:20:01 +01:00
|
|
|
}
|
|
|
|
|
|
2019-09-04 14:44:51 +02:00
|
|
|
#if !defined(MBEDTLS_MD_SINGLE_HASH)
|
2015-04-08 12:49:31 +02:00
|
|
|
int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
|
2013-03-13 10:26:44 +01:00
|
|
|
{
|
2019-09-04 14:44:51 +02:00
|
|
|
return( mbedtls_md_process_internal( ctx, data ) );
|
2013-03-13 10:26:44 +01:00
|
|
|
}
|
2019-09-04 14:44:51 +02:00
|
|
|
#endif /* !MBEDTLS_MD_SINGLE_HASH */
|
2013-03-13 10:26:44 +01:00
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
unsigned char mbedtls_md_get_size( mbedtls_md_handle_t md_info )
|
2015-03-24 12:13:30 +01:00
|
|
|
{
|
2019-07-17 12:21:02 +02:00
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-03-24 12:13:30 +01:00
|
|
|
return( 0 );
|
|
|
|
|
|
2019-07-17 15:10:26 +02:00
|
|
|
return mbedtls_md_info_size( md_info );
|
2015-03-24 12:13:30 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
mbedtls_md_type_t mbedtls_md_get_type( mbedtls_md_handle_t md_info )
|
2015-03-24 12:13:30 +01:00
|
|
|
{
|
2019-07-17 12:21:02 +02:00
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-04-08 12:49:31 +02:00
|
|
|
return( MBEDTLS_MD_NONE );
|
2015-03-24 12:13:30 +01:00
|
|
|
|
2019-07-17 15:10:26 +02:00
|
|
|
return mbedtls_md_info_type( md_info );
|
2015-03-24 12:13:30 +01:00
|
|
|
}
|
|
|
|
|
|
2019-07-17 12:21:02 +02:00
|
|
|
const char *mbedtls_md_get_name( mbedtls_md_handle_t md_info )
|
2015-03-24 12:13:30 +01:00
|
|
|
{
|
2019-07-17 12:21:02 +02:00
|
|
|
if( md_info == MBEDTLS_MD_INVALID_HANDLE )
|
2015-03-24 12:13:30 +01:00
|
|
|
return( NULL );
|
|
|
|
|
|
2019-07-17 15:10:26 +02:00
|
|
|
return mbedtls_md_info_name( md_info );
|
2015-03-24 12:13:30 +01:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 12:49:31 +02:00
|
|
|
#endif /* MBEDTLS_MD_C */
|