AuroraMiddleware/mbedtls
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
d3f73349a7
mbedtls/library/md.c

813 lines
22 KiB
C
Raw Normal View History

- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
/**
Fix wrong \file name in Doxygen comments Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2021-02-12 22:34:01 +00:00
* \file md.c
Fix formatting: remove trailing spaces, #endif with comments (> 10 lines)
2014-05-01 11:03:14 +00:00
*
Rename to mbed TLS in the documentation/comments
2015-01-22 16:11:05 +00:00
* \brief Generic message digest wrapper for mbed TLS
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
*
* \author Adriaan de Jong <dejong@fox-it.com>
*
Update copyright notices to use Linux Foundation guidance As a result, the copyright of contributors other than Arm is now acknowledged, and the years of publishing are no longer tracked in the source files. Also remove the now-redundant lines declaring that the files are part of MbedTLS. This commit was generated using the following script: # ======================== #!/bin/sh # Find files find '(' -path './.git' -o -path './3rdparty' ')' -prune -o -type f -print | xargs sed -bi ' # Replace copyright attribution line s/Copyright.*Arm.*/Copyright The Mbed TLS Contributors/I # Remove redundant declaration and the preceding line $!N /This file is part of Mbed TLS/Id P D ' # ======================== Signed-off-by: Bence Szépkúti <bence.szepkuti@arm.com>
2020-08-07 11:07:28 +00:00
* Copyright The Mbed TLS Contributors
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* SPDX-License-Identifier: Apache-2.0
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00: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
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00:00
* http://www.apache.org/licenses/LICENSE-2.0
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
*
Change main license to Apache 2.0
2015-09-04 12:21:07 +00: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.
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
*/
Include common.h instead of config.h in library source files In library source files, include "common.h", which takes care of including "mbedtls/config.h" (or the alternative MBEDTLS_CONFIG_FILE) and other things that are used throughout the library. FROM=$'#if !defined(MBEDTLS_CONFIG_FILE)\n#include "mbedtls/config.h"\n#else\n#include MBEDTLS_CONFIG_FILE\n#endif' perl -i -0777 -pe 's~\Q$ENV{FROM}~#include "common.h"~' library/*.c 3rdparty/*/library/*.c scripts/data_files/error.fmt scripts/data_files/version_features.fmt Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-06-02 23:43:33 +00:00
#include "common.h"
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_MD_C)
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Rename include directory to mbedtls
2015-03-09 17:05:11 +00:00
#include "mbedtls/md.h"
Rename <pk/md/cipher>_internal.h to *_wrap.h Revert changes introduced in 50518f419589d2c4746f4b6d6be0a2569a3386a8 as it is now clear that these headers are internal without the `*_internal.h` suffix. Signed-off-by: Chris Jones <christopher.jones@arm.com>
2021-03-09 17:03:29 +00:00
#include "md_wrap.h"
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
#include "mbedtls/platform_util.h"
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
#include "mbedtls/error.h"
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#include "mbedtls/md5.h"
#include "mbedtls/ripemd160.h"
#include "mbedtls/sha1.h"
#include "mbedtls/sha256.h"
#include "mbedtls/sha512.h"
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_PLATFORM_C)
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
#include "mbedtls/platform.h"
#else
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#include <stdlib.h>
Replace malloc with calloc - platform layer currently broken (not adapted yet) - memmory_buffer_alloc too
2015-05-26 14:04:06 +00:00
#define mbedtls_calloc calloc
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#define mbedtls_free free
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
#endif
cleanup library and some basic tests. Includes, add guards to includes
2015-02-06 13:43:58 +00:00
#include <string.h>
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
#if defined(MBEDTLS_FS_IO)
#include <stdio.h>
- Improved portability with Microsoft Visual C
2011-04-18 03:47:52 +00:00
#endif
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#if defined(MBEDTLS_MD5_C)
const mbedtls_md_info_t mbedtls_md5_info = {
"MD5",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_MD5,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
16,
64,
};
#endif
#if defined(MBEDTLS_RIPEMD160_C)
const mbedtls_md_info_t mbedtls_ripemd160_info = {
"RIPEMD160",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_RIPEMD160,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
20,
64,
};
#endif
#if defined(MBEDTLS_SHA1_C)
const mbedtls_md_info_t mbedtls_sha1_info = {
"SHA1",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_SHA1,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
20,
64,
};
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
const mbedtls_md_info_t mbedtls_sha224_info = {
"SHA224",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_SHA224,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
28,
64,
};
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
const mbedtls_md_info_t mbedtls_sha256_info = {
"SHA256",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_SHA256,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
32,
64,
};
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
const mbedtls_md_info_t mbedtls_sha384_info = {
"SHA384",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_SHA384,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
48,
128,
};
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
const mbedtls_md_info_t mbedtls_sha512_info = {
"SHA512",
Use smaller types in mbedtls_md_info_t Saves a few bytes of code size.
2019-07-19 14:03:39 +00:00
MBEDTLS_MD_SHA512,
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
64,
128,
};
#endif
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
/*
Revert "md: Remove dependency on X.509" This reverts commit ebbc5f7940e5271d3cdd31818119d558ba040155.
2020-02-26 18:52:06 +00:00
* Reminder: update profiles in x509_crt.c when adding a new hash!
Add pre-defined profiles for cert verification
2015-06-15 12:34:59 +00:00
*/
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
static const int supported_digests[] = {
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_SHA512_C)
MBEDTLS_MD_SHA512,
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
MBEDTLS_MD_SHA384,
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_SHA256_C)
MBEDTLS_MD_SHA256,
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA224_C)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
MBEDTLS_MD_SHA224,
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_SHA1_C)
MBEDTLS_MD_SHA1,
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_RIPEMD160_C)
MBEDTLS_MD_RIPEMD160,
Add RIPEMD-160 to the generic MD layer
2014-01-17 19:41:32 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_MD5_C)
MBEDTLS_MD_MD5,
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
MBEDTLS_MD_NONE
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
};
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const int *mbedtls_md_list( void )
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
{
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( supported_digests );
- Improved information provided about current Hashing, Cipher and Suite capabilities
2011-01-16 21:27:44 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_md_info_t *mbedtls_md_info_from_string( const char *md_name )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
if( NULL == md_name )
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( NULL );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
/* Get the appropriate digest information */
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_MD5_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "MD5", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_MD5 );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_RIPEMD160_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "RIPEMD160", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_RIPEMD160 );
Add RIPEMD-160 to the generic MD layer
2014-01-17 19:41:32 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_SHA1_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "SHA1", md_name ) || !strcmp( "SHA", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA1 );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "SHA224", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA224 );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "SHA256", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA256 );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "SHA384", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA384 );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Avoid non-standard strcasecmp()
2015-05-28 15:06:07 +00:00
if( !strcmp( "SHA512", md_name ) )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return mbedtls_md_info_from_type( MBEDTLS_MD_SHA512 );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( NULL );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const mbedtls_md_info_t *mbedtls_md_info_from_type( mbedtls_md_type_t md_type )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
switch( md_type )
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
return( &mbedtls_md5_info );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
return( &mbedtls_ripemd160_info );
Add RIPEMD-160 to the generic MD layer
2014-01-17 19:41:32 +00:00
#endif
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
return( &mbedtls_sha1_info );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_MD_SHA224:
return( &mbedtls_sha224_info );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_MD_SHA256:
return( &mbedtls_sha256_info );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_MD_SHA384:
return( &mbedtls_sha384_info );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
case MBEDTLS_MD_SHA512:
return( &mbedtls_sha512_info );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
#endif
default:
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( NULL );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
void mbedtls_md_init( mbedtls_md_context_t *ctx )
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
memset( ctx, 0, sizeof( mbedtls_md_context_t ) );
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
void mbedtls_md_free( mbedtls_md_context_t *ctx )
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
{
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx == NULL || ctx->md_info == NULL )
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
return;
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx->md_ctx != NULL )
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
{
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
mbedtls_md5_free( ctx->md_ctx );
break;
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
mbedtls_ripemd160_free( ctx->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
mbedtls_sha1_free( ctx->md_ctx );
break;
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
mbedtls_sha256_free( ctx->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
mbedtls_sha256_free( ctx->md_ctx );
break;
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
mbedtls_sha512_free( ctx->md_ctx );
break;
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
mbedtls_sha512_free( ctx->md_ctx );
break;
#endif
default:
/* Shouldn't happen */
break;
}
mbedtls_free( ctx->md_ctx );
}
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx->hmac_ctx != NULL )
{
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( ctx->hmac_ctx,
2 * ctx->md_info->block_size );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_free( ctx->hmac_ctx );
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
}
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( ctx, sizeof( mbedtls_md_context_t ) );
Adapt cipher and MD layer with _init() and _free()
2014-07-01 12:53:22 +00:00
}
Add mbedtls_md_clone()
2015-07-06 14:06:02 +00:00
int mbedtls_md_clone( mbedtls_md_context_t *dst,
const mbedtls_md_context_t *src )
{
if( dst == NULL || dst->md_info == NULL ||
src == NULL || src->md_info == NULL ||
dst->md_info != src->md_info )
{
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( src->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
mbedtls_md5_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
mbedtls_ripemd160_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
mbedtls_sha1_clone( dst->md_ctx, src->md_ctx );
break;
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
mbedtls_sha256_clone( dst->md_ctx, src->md_ctx );
break;
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
mbedtls_sha256_clone( dst->md_ctx, src->md_ctx );
break;
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
break;
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
mbedtls_sha512_clone( dst->md_ctx, src->md_ctx );
break;
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
Add mbedtls_md_clone()
2015-07-06 14:06:02 +00:00
return( 0 );
}
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#define ALLOC( type ) \
do { \
ctx->md_ctx = mbedtls_calloc( 1, sizeof( mbedtls_##type##_context ) ); \
if( ctx->md_ctx == NULL ) \
return( MBEDTLS_ERR_MD_ALLOC_FAILED ); \
mbedtls_##type##_init( ctx->md_ctx ); \
} \
while( 0 )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_setup( mbedtls_md_context_t *ctx, const mbedtls_md_info_t *md_info, int hmac )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
- Fixed size of clean
2012-04-26 10:09:35 +00:00
if( md_info == NULL || ctx == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Fix memory leak in mbedtls_md_setup with HMAC mbedtls_md_setup() allocates a hash-specific context and then, if requested, an extra HMAC context. If the second allocation failed, the hash context was not freed. Fix this by ensuring that the mbedtls_md_context_t object is always in a consistent state, in particular, that the md_info field is always set. For robustness, ensure that the object is in a consistent state even on errors (other than BAD_INPUT_DATA if the object was not in a consistent state on entry). Fix #3486 Signed-off-by: Gilles Peskine <Gilles.Peskine@arm.com>
2020-08-19 10:03:11 +00:00
ctx->md_info = md_info;
ctx->md_ctx = NULL;
ctx->hmac_ctx = NULL;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
ALLOC( md5 );
break;
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
ALLOC( ripemd160 );
break;
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
ALLOC( sha1 );
break;
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
ALLOC( sha256 );
break;
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
ALLOC( sha256 );
break;
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
ALLOC( sha512 );
break;
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
ALLOC( sha512 );
break;
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Make hmac_ctx optional Note from future self: actually md_init_ctx will be re-introduced with the same signature later, and a new function with the additional argument will be added.
2015-03-25 15:08:53 +00:00
if( hmac != 0 )
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
{
Replace malloc with calloc - platform layer currently broken (not adapted yet) - memmory_buffer_alloc too
2015-05-26 14:04:06 +00:00
ctx->hmac_ctx = mbedtls_calloc( 2, md_info->block_size );
Make hmac_ctx optional Note from future self: actually md_init_ctx will be re-introduced with the same signature later, and a new function with the additional argument will be added.
2015-03-25 15:08:53 +00:00
if( ctx->hmac_ctx == NULL )
{
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
mbedtls_md_free( ctx );
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_ALLOC_FAILED );
Make hmac_ctx optional Note from future self: actually md_init_ctx will be re-introduced with the same signature later, and a new function with the additional argument will be added.
2015-03-25 15:08:53 +00:00
}
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
}
Fix code styling for return statements
2014-06-17 12:06:49 +00:00
return( 0 );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#undef ALLOC
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_starts( mbedtls_md_context_t *ctx )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
if( ctx == NULL || ctx->md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_md5_starts( ctx->md_ctx ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_ripemd160_starts( ctx->md_ctx ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha1_starts( ctx->md_ctx ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_starts( ctx->md_ctx, 1 ) );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_starts( ctx->md_ctx, 0 ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_starts( ctx->md_ctx, 1 ) );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_starts( ctx->md_ctx, 0 ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
if( ctx == NULL || ctx->md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_md5_update( ctx->md_ctx, input, ilen ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_ripemd160_update( ctx->md_ctx, input, ilen ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha1_update( ctx->md_ctx, input, ilen ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_update( ctx->md_ctx, input, ilen ) );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_update( ctx->md_ctx, input, ilen ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_update( ctx->md_ctx, input, ilen ) );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_update( ctx->md_ctx, input, ilen ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
- Split current md_starts() and md_hmac_starts() functionality into separate md_init_ctx() for allocating the context and the existing starts() functions to initialize the message digest for use.
2011-01-20 16:42:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_finish( mbedtls_md_context_t *ctx, unsigned char *output )
- Split current md_starts() and md_hmac_starts() functionality into separate md_init_ctx() for allocating the context and the existing starts() functions to initialize the message digest for use.
2011-01-20 16:42:01 +00:00
{
if( ctx == NULL || ctx->md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Split current md_starts() and md_hmac_starts() functionality into separate md_init_ctx() for allocating the context and the existing starts() functions to initialize the message digest for use.
2011-01-20 16:42:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_md5_finish( ctx->md_ctx, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_ripemd160_finish( ctx->md_ctx, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha1_finish( ctx->md_ctx, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_finish( ctx->md_ctx, output ) );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256_finish( ctx->md_ctx, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_finish( ctx->md_ctx, output ) );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512_finish( ctx->md_ctx, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md( const mbedtls_md_info_t *md_info, const unsigned char *input, size_t ilen,
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
unsigned char *output )
{
Fix formatting in various code to match spacing from coding style
2014-06-17 14:39:18 +00:00
if( md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_md5( input, ilen, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_ripemd160( input, ilen, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha1( input, ilen, output ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256( input, ilen, output, 1 ) );
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha256( input, ilen, output, 0 ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512( input, ilen, output, 1 ) );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
Rename the _ret() functions Signed-off-by: TRodziewicz <tomasz.rodziewicz@mobica.com>
2021-06-08 14:45:41 +00:00
return( mbedtls_sha512( input, ilen, output, 0 ) );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
#if defined(MBEDTLS_FS_IO)
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_file( const mbedtls_md_info_t *md_info, const char *path, unsigned char *output )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
FILE *f;
size_t n;
mbedtls_md_context_t ctx;
unsigned char buf[1024];
- Added regular error codes for generic message digest layer
2011-06-09 15:55:11 +00:00
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
if( md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
if( ( f = fopen( path, "rb" ) ) == NULL )
Avoid fclose( NULL ) Found by Coverity Scan.
2015-06-23 22:09:29 +00:00
return( MBEDTLS_ERR_MD_FILE_IO_ERROR );
mbedtls_md_init( &ctx );
- Functions requiring File System functions can now be disables by undefining POLARSSL_FS_IO
2011-04-25 15:28:35 +00:00
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
if( ( ret = mbedtls_md_setup( &ctx, md_info, 0 ) ) != 0 )
goto cleanup;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_starts( &ctx ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
while( ( n = fread( buf, 1, sizeof( buf ), f ) ) > 0 )
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_update( &ctx, buf, n ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
if( ferror( f ) != 0 )
ret = MBEDTLS_ERR_MD_FILE_IO_ERROR;
Zeroize tmp buf in mbedtls_md_file() md.c
2017-06-23 15:30:31 +00:00
else
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
ret = mbedtls_md_finish( &ctx, output );
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
cleanup:
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( buf, sizeof( buf ) );
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
fclose( f );
mbedtls_md_free( &ctx );
return( ret );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
Implement md_file in the MD layer
2015-05-28 12:44:00 +00:00
#endif /* MBEDTLS_FS_IO */
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_hmac_starts( mbedtls_md_context_t *ctx, const unsigned char *key, size_t keylen )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
unsigned char sum[MBEDTLS_MD_MAX_SIZE];
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
unsigned char *ipad, *opad;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
size_t i;
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
if( keylen > (size_t) ctx->md_info->block_size )
{
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_update( ctx, key, keylen ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_finish( ctx, sum ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
keylen = ctx->md_info->size;
key = sum;
}
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
ipad = (unsigned char *) ctx->hmac_ctx;
opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
memset( ipad, 0x36, ctx->md_info->block_size );
memset( opad, 0x5C, ctx->md_info->block_size );
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
for( i = 0; i < keylen; i++ )
{
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
ipad[i] = (unsigned char)( ipad[i] ^ key[i] );
opad[i] = (unsigned char)( opad[i] ^ key[i] );
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
}
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_update( ctx, ipad,
ctx->md_info->block_size ) ) != 0 )
Add goto cleanup; for consistency md.c
2017-07-20 15:27:03 +00:00
goto cleanup;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
cleanup:
Rename mbedtls_zeroize to mbedtls_platform_zeroize
2018-04-17 14:51:09 +00:00
mbedtls_platform_zeroize( sum, sizeof( sum ) );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_hmac_update( mbedtls_md_context_t *ctx, const unsigned char *input, size_t ilen )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
return( mbedtls_md_update( ctx, input, ilen ) );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_hmac_finish( mbedtls_md_context_t *ctx, unsigned char *output )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
unsigned char tmp[MBEDTLS_MD_MAX_SIZE];
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
unsigned char *opad;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
opad = (unsigned char *) ctx->hmac_ctx + ctx->md_info->block_size;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_finish( ctx, tmp ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_update( ctx, opad,
ctx->md_info->block_size ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_update( ctx, tmp,
ctx->md_info->size ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
return( mbedtls_md_finish( ctx, output ) );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_hmac_reset( mbedtls_md_context_t *ctx )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
unsigned char *ipad;
if( ctx == NULL || ctx->md_info == NULL || ctx->hmac_ctx == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Make ipad/opad dynamic and more opaque
2015-03-25 10:49:07 +00:00
ipad = (unsigned char *) ctx->hmac_ctx;
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
if( ( ret = mbedtls_md_starts( ctx ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
return( mbedtls_md_update( ctx, ipad, ctx->md_info->block_size ) );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
int mbedtls_md_hmac( const mbedtls_md_info_t *md_info,
const unsigned char *key, size_t keylen,
const unsigned char *input, size_t ilen,
unsigned char *output )
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
{
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_md_context_t ctx;
Initialise return values to an error Initialising the return values to and error is best practice and makes the library more robust.
2019-11-22 13:21:35 +00:00
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
if( md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_md_init( &ctx );
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
if( ( ret = mbedtls_md_setup( &ctx, md_info, 1 ) ) != 0 )
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
goto cleanup;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00: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;
Fix indentation and add goto cleanup; stmt
2017-07-21 13:21:53 +00:00
if( ( ret = mbedtls_md_hmac_finish( &ctx, output ) ) != 0 )
goto cleanup;
Implement hmac in the MD layer
2015-03-24 15:48:22 +00:00
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
cleanup:
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_md_free( &ctx );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
Fix functions in MD layer to check return codes
2017-06-28 13:16:07 +00:00
return( ret );
- Added generic message digest wrapper for integration with OpenVPN (donated by Fox-IT)
2011-01-06 14:20:01 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
int mbedtls_md_process( mbedtls_md_context_t *ctx, const unsigned char *data )
Added md_process() to MD layer for generic internal access to hash process functions Access to process functions is needed to reduce possible timing attacks on SSL MAC checks. As SSL is set to move to using the dynamic MD layer, the MD layer needs access to these process functions as well.
2013-03-13 09:26:44 +00:00
{
if( ctx == NULL || ctx->md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
Added md_process() to MD layer for generic internal access to hash process functions Access to process functions is needed to reduce possible timing attacks on SSL MAC checks. As SSL is set to move to using the dynamic MD layer, the MD layer needs access to these process functions as well.
2013-03-13 09:26:44 +00:00
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
switch( ctx->md_info->type )
{
#if defined(MBEDTLS_MD5_C)
case MBEDTLS_MD_MD5:
return( mbedtls_internal_md5_process( ctx->md_ctx, data ) );
#endif
#if defined(MBEDTLS_RIPEMD160_C)
case MBEDTLS_MD_RIPEMD160:
return( mbedtls_internal_ripemd160_process( ctx->md_ctx, data ) );
#endif
#if defined(MBEDTLS_SHA1_C)
case MBEDTLS_MD_SHA1:
return( mbedtls_internal_sha1_process( ctx->md_ctx, data ) );
#endif
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
#if defined(MBEDTLS_SHA224_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA224:
Separate SHA224 from SHA256 config options. These options are still dependant on each other. This is an intermediate step. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-19 14:46:28 +00:00
return( mbedtls_internal_sha256_process( ctx->md_ctx, data ) );
#endif
#if defined(MBEDTLS_SHA256_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA256:
return( mbedtls_internal_sha256_process( ctx->md_ctx, data ) );
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA384_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA384:
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
return( mbedtls_internal_sha512_process( ctx->md_ctx, data ) );
Implement NO_SHA384 in MD layer and PSA
2019-07-17 14:28:21 +00:00
#endif
Modify config option for SHA384. Although SHA512 is currently required to enable SHA384, this is expected to change in the future. This commit is an intermediate step towards fully separating SHA384 and SHA512. check_config is the only module which enforces that SHA512 is enabled together with SHA384. Signed-off-by: Mateusz Starzyk <mateusz.starzyk@mobica.com>
2021-04-06 12:28:22 +00:00
#if defined(MBEDTLS_SHA512_C)
Don't use dynamic pointer dispatch in md In the generic message digest abstraction, instead of storing method pointers in the per-algorithm data structure and using wrapper functions as those methods, call the per-algorithm function directly. This saves some code size (2336B -> 2043B for md with all algorithms enabled on M0+ with gcc -Os). This should also make it easier to optimize the case when a single algorithm is supported. In addition, this is a very slight security improvement since it removes one opportunity for a buffer overflow to directly turn into letting the attacker overwrite a pointer to a function pointer. This commit does not modify the documented API. However, it removes the possibility for users to define their own hash implementations and use them by building their own md_info. Changing mbedtls_md_context to contain a md type identifier rather than a pointer to an info structure would save a few more bytes and a few more runtime memory accesses, but would be a major API break since a lot of code uses `const mbedtls_md_info *` to keep track of which hash is in use.
2019-07-19 13:46:03 +00:00
case MBEDTLS_MD_SHA512:
return( mbedtls_internal_sha512_process( ctx->md_ctx, data ) );
#endif
default:
return( MBEDTLS_ERR_MD_BAD_INPUT_DATA );
}
Added md_process() to MD layer for generic internal access to hash process functions Access to process functions is needed to reduce possible timing attacks on SSL MAC checks. As SSL is set to move to using the dynamic MD layer, the MD layer needs access to these process functions as well.
2013-03-13 09:26:44 +00:00
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
unsigned char mbedtls_md_get_size( const mbedtls_md_info_t *md_info )
Make md_info_t an opaque structure - more freedom for us to change it in the future - enforces hygiene - performance impact of making accessors no longer inline should really be negligible
2015-03-24 11:13:30 +00:00
{
if( md_info == NULL )
return( 0 );
return md_info->size;
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
mbedtls_md_type_t mbedtls_md_get_type( const mbedtls_md_info_t *md_info )
Make md_info_t an opaque structure - more freedom for us to change it in the future - enforces hygiene - performance impact of making accessors no longer inline should really be negligible
2015-03-24 11:13:30 +00:00
{
if( md_info == NULL )
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
return( MBEDTLS_MD_NONE );
Make md_info_t an opaque structure - more freedom for us to change it in the future - enforces hygiene - performance impact of making accessors no longer inline should really be negligible
2015-03-24 11:13:30 +00:00
return md_info->type;
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
const char *mbedtls_md_get_name( const mbedtls_md_info_t *md_info )
Make md_info_t an opaque structure - more freedom for us to change it in the future - enforces hygiene - performance impact of making accessors no longer inline should really be negligible
2015-03-24 11:13:30 +00:00
{
if( md_info == NULL )
return( NULL );
return md_info->name;
}
The Great Renaming A simple execution of tmp/invoke-rename.pl
2015-04-08 10:49:31 +00:00
#endif /* MBEDTLS_MD_C */
Reference in New Issue Copy Permalink