kris/boringssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
387b07b78d
boringssl/crypto/fipsmodule/sha/sha512.c

536 lines
18 KiB
C
Raw Normal View History

Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
* All rights reserved.
*
* This package is an SSL implementation written
* by Eric Young (eay@cryptsoft.com).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
*
* Copyright remains Eric Young's, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* Eric Young (eay@cryptsoft.com)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.] */
#include <openssl/sha.h>
#include <string.h>
#include <openssl/mem.h>
Add ABI tests for SHA*. Bug: 181 Change-Id: Ica9299613d7fd1b803533b7e489b9ba8fe816a24 Reviewed-on: https://boringssl-review.googlesource.com/c/33968 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2018-12-31 07:31:44 +00:00
#include "internal.h"
First part of the FIPS module. Change-Id: Ic3a91ccd2c8cdc364740f256fdb8a7ff66177947 Reviewed-on: https://boringssl-review.googlesource.com/14506 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com>
2017-04-04 22:21:43 +01:00
#include "../../internal.h"
Work around language and compiler bug in memcpy, etc. Most C standard library functions are undefined if passed NULL, even when the corresponding length is zero. This gives them (and, in turn, all functions which call them) surprising behavior on empty arrays. Some compilers will miscompile code due to this rule. See also https://www.imperialviolet.org/2016/06/26/nonnull.html Add OPENSSL_memcpy, etc., wrappers which avoid this problem. BUG=23 Change-Id: I95f42b23e92945af0e681264fffaf578e7f8465e Reviewed-on: https://boringssl-review.googlesource.com/12928 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-12-13 06:07:13 +00:00
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// The 32-bit hash algorithms share a common byte-order neutral collector and
// padding function implementations that operate on unaligned data,
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
// ../digest/md32_common.h. SHA-512 is the only 64-bit hash algorithm, as of
// this writing, so there is no need for a common collector/padding
// implementation yet.
Allow SHA-512 unaligned data access in |OPENSSL_NO_ASM| mode. The previous logic only defined |SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA| when the assembly language optimizations were enabled, but |SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA| is also useful when the C implementations are used. If support for ARM processors that don't support unaligned access is important, then it might be better to condition the enabling of |SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA| on ARM based on more specific flags. Change-Id: Ie8c37c73aba308c3ccf79371ce5831512e419989 Reviewed-on: https://boringssl-review.googlesource.com/6402 Reviewed-by: Adam Langley <agl@google.com>
2015-11-03 01:05:11 +00:00
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
int SHA384_Init(SHA512_CTX *sha) {
Use UINT64_C instead of OPENSSL_U64. stdint.h already has macros for this. The spec says that, in C++, __STDC_CONSTANT_MACROS is needed, so define it for bytestring_test.cc. Chromium seems to use these macros without trouble, so I'm assuming we can rely on them. Change-Id: I56d178689b44d22c6379911bbb93d3b01dd832a3 Reviewed-on: https://boringssl-review.googlesource.com/6510 Reviewed-by: Adam Langley <agl@google.com>
2015-11-14 16:57:11 +00:00
sha->h[0] = UINT64_C(0xcbbb9d5dc1059ed8);
sha->h[1] = UINT64_C(0x629a292a367cd507);
sha->h[2] = UINT64_C(0x9159015a3070dd17);
sha->h[3] = UINT64_C(0x152fecd8f70e5939);
sha->h[4] = UINT64_C(0x67332667ffc00b31);
sha->h[5] = UINT64_C(0x8eb44a8768581511);
sha->h[6] = UINT64_C(0xdb0c2e0d64f98fa7);
sha->h[7] = UINT64_C(0x47b5481dbefa4fa4);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
sha->Nl = 0;
sha->Nh = 0;
sha->num = 0;
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
sha->md_len = SHA384_DIGEST_LENGTH;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
return 1;
}
int SHA512_Init(SHA512_CTX *sha) {
Use UINT64_C instead of OPENSSL_U64. stdint.h already has macros for this. The spec says that, in C++, __STDC_CONSTANT_MACROS is needed, so define it for bytestring_test.cc. Chromium seems to use these macros without trouble, so I'm assuming we can rely on them. Change-Id: I56d178689b44d22c6379911bbb93d3b01dd832a3 Reviewed-on: https://boringssl-review.googlesource.com/6510 Reviewed-by: Adam Langley <agl@google.com>
2015-11-14 16:57:11 +00:00
sha->h[0] = UINT64_C(0x6a09e667f3bcc908);
sha->h[1] = UINT64_C(0xbb67ae8584caa73b);
sha->h[2] = UINT64_C(0x3c6ef372fe94f82b);
sha->h[3] = UINT64_C(0xa54ff53a5f1d36f1);
sha->h[4] = UINT64_C(0x510e527fade682d1);
sha->h[5] = UINT64_C(0x9b05688c2b3e6c1f);
sha->h[6] = UINT64_C(0x1f83d9abfb41bd6b);
sha->h[7] = UINT64_C(0x5be0cd19137e2179);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
sha->Nl = 0;
sha->Nh = 0;
sha->num = 0;
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
sha->md_len = SHA512_DIGEST_LENGTH;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
return 1;
}
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
uint8_t *SHA384(const uint8_t *data, size_t len,
uint8_t out[SHA384_DIGEST_LENGTH]) {
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
SHA512_CTX ctx;
SHA384_Init(&ctx);
Don't mismatch Init and Update/Final hash functions. Fixes the ASan bot. Change-Id: I29b9b98680b634c5e486a734afa38f9d4e458518 Reviewed-on: https://boringssl-review.googlesource.com/7792 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:51:17 +01:00
SHA384_Update(&ctx, data, len);
SHA384_Final(out, &ctx);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
uint8_t *SHA512(const uint8_t *data, size_t len,
uint8_t out[SHA512_DIGEST_LENGTH]) {
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
SHA512_CTX ctx;
SHA512_Init(&ctx);
SHA512_Update(&ctx, data, len);
SHA512_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
#if !defined(SHA512_ASM)
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
static void sha512_block_data_order(uint64_t *state, const uint8_t *in,
size_t num_blocks);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#endif
Make SHA512_Final actually only return one. Rather than store md_len, factor out the common parts of SHA384_Final and SHA512_Final and then extract the right state. Also add a missing SHA384_Transform and be consistent about "1" vs "one" in comments. This also removes the NULL output special-case which no other hash function had. Change-Id: If60008bae7d7d5b123046a46d8fd64139156a7c5 Reviewed-on: https://boringssl-review.googlesource.com/7720 Reviewed-by: Adam Langley <agl@google.com>
2016-04-19 22:39:28 +01:00
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
int SHA384_Final(uint8_t out[SHA384_DIGEST_LENGTH], SHA512_CTX *sha) {
// |SHA384_Init| sets |sha->md_len| to |SHA384_DIGEST_LENGTH|, so this has a
// |smaller output.
return SHA512_Final(out, sha);
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
}
Make SHA512_Final actually only return one. Rather than store md_len, factor out the common parts of SHA384_Final and SHA512_Final and then extract the right state. Also add a missing SHA384_Transform and be consistent about "1" vs "one" in comments. This also removes the NULL output special-case which no other hash function had. Change-Id: If60008bae7d7d5b123046a46d8fd64139156a7c5 Reviewed-on: https://boringssl-review.googlesource.com/7720 Reviewed-by: Adam Langley <agl@google.com>
2016-04-19 22:39:28 +01:00
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
int SHA384_Update(SHA512_CTX *sha, const void *data, size_t len) {
return SHA512_Update(sha, data, len);
Make SHA512_Final actually only return one. Rather than store md_len, factor out the common parts of SHA384_Final and SHA512_Final and then extract the right state. Also add a missing SHA384_Transform and be consistent about "1" vs "one" in comments. This also removes the NULL output special-case which no other hash function had. Change-Id: If60008bae7d7d5b123046a46d8fd64139156a7c5 Reviewed-on: https://boringssl-review.googlesource.com/7720 Reviewed-by: Adam Langley <agl@google.com>
2016-04-19 22:39:28 +01:00
}
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
void SHA512_Transform(SHA512_CTX *c, const uint8_t block[SHA512_CBLOCK]) {
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
sha512_block_data_order(c->h, block, 1);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
int SHA512_Update(SHA512_CTX *c, const void *in_data, size_t len) {
uint64_t l;
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
uint8_t *p = c->p;
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
const uint8_t *data = in_data;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Add in missing curly braces part 3. Everything else. Change-Id: Iac02b144465b4e7b6d69ea22ff2aaf52695ae732
2015-02-11 06:17:41 +00:00
if (len == 0) {
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
return 1;
Add in missing curly braces part 3. Everything else. Change-Id: Iac02b144465b4e7b6d69ea22ff2aaf52695ae732
2015-02-11 06:17:41 +00:00
}
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Use UINT64_C instead of OPENSSL_U64. stdint.h already has macros for this. The spec says that, in C++, __STDC_CONSTANT_MACROS is needed, so define it for bytestring_test.cc. Chromium seems to use these macros without trouble, so I'm assuming we can rely on them. Change-Id: I56d178689b44d22c6379911bbb93d3b01dd832a3 Reviewed-on: https://boringssl-review.googlesource.com/6510 Reviewed-by: Adam Langley <agl@google.com>
2015-11-14 16:57:11 +00:00
l = (c->Nl + (((uint64_t)len) << 3)) & UINT64_C(0xffffffffffffffff);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
if (l < c->Nl) {
c->Nh++;
}
if (sizeof(len) >= 8) {
c->Nh += (((uint64_t)len) >> 61);
}
c->Nl = l;
if (c->num != 0) {
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
size_t n = sizeof(c->p) - c->num;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
if (len < n) {
Work around language and compiler bug in memcpy, etc. Most C standard library functions are undefined if passed NULL, even when the corresponding length is zero. This gives them (and, in turn, all functions which call them) surprising behavior on empty arrays. Some compilers will miscompile code due to this rule. See also https://www.imperialviolet.org/2016/06/26/nonnull.html Add OPENSSL_memcpy, etc., wrappers which avoid this problem. BUG=23 Change-Id: I95f42b23e92945af0e681264fffaf578e7f8465e Reviewed-on: https://boringssl-review.googlesource.com/12928 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-12-13 06:07:13 +00:00
OPENSSL_memcpy(p + c->num, data, len);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
c->num += (unsigned int)len;
return 1;
} else {
Work around language and compiler bug in memcpy, etc. Most C standard library functions are undefined if passed NULL, even when the corresponding length is zero. This gives them (and, in turn, all functions which call them) surprising behavior on empty arrays. Some compilers will miscompile code due to this rule. See also https://www.imperialviolet.org/2016/06/26/nonnull.html Add OPENSSL_memcpy, etc., wrappers which avoid this problem. BUG=23 Change-Id: I95f42b23e92945af0e681264fffaf578e7f8465e Reviewed-on: https://boringssl-review.googlesource.com/12928 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-12-13 06:07:13 +00:00
OPENSSL_memcpy(p + c->num, data, n), c->num = 0;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
len -= n;
data += n;
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
sha512_block_data_order(c->h, p, 1);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
}
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
if (len >= sizeof(c->p)) {
sha512_block_data_order(c->h, data, len / sizeof(c->p));
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
data += len;
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
len %= sizeof(c->p);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
data -= len;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
if (len != 0) {
Work around language and compiler bug in memcpy, etc. Most C standard library functions are undefined if passed NULL, even when the corresponding length is zero. This gives them (and, in turn, all functions which call them) surprising behavior on empty arrays. Some compilers will miscompile code due to this rule. See also https://www.imperialviolet.org/2016/06/26/nonnull.html Add OPENSSL_memcpy, etc., wrappers which avoid this problem. BUG=23 Change-Id: I95f42b23e92945af0e681264fffaf578e7f8465e Reviewed-on: https://boringssl-review.googlesource.com/12928 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2016-12-13 06:07:13 +00:00
OPENSSL_memcpy(p, data, len);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
c->num = (int)len;
}
return 1;
}
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
int SHA512_Final(uint8_t out[SHA512_DIGEST_LENGTH], SHA512_CTX *sha) {
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
uint8_t *p = sha->p;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
size_t n = sha->num;
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
p[n] = 0x80; // There always is a room for one
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
n++;
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
if (n > (sizeof(sha->p) - 16)) {
OPENSSL_memset(p + n, 0, sizeof(sha->p) - n);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
n = 0;
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
sha512_block_data_order(sha->h, p, 1);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
Remove union from |SHA512_CTX|. With 2fe0360a4e1b988e7b0aa0b4348bf55805512c09, we no longer use the other member of this union so it can be removed. Change-Id: Ideb7c47a72df0b420eb1e7d8c718e1cacb2129f5 Reviewed-on: https://boringssl-review.googlesource.com/c/34449 Commit-Queue: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: David Benjamin <davidben@google.com>
2019-01-22 23:24:26 +00:00
OPENSSL_memset(p + n, 0, sizeof(sha->p) - 16 - n);
p[sizeof(sha->p) - 1] = (uint8_t)(sha->Nl);
p[sizeof(sha->p) - 2] = (uint8_t)(sha->Nl >> 8);
p[sizeof(sha->p) - 3] = (uint8_t)(sha->Nl >> 16);
p[sizeof(sha->p) - 4] = (uint8_t)(sha->Nl >> 24);
p[sizeof(sha->p) - 5] = (uint8_t)(sha->Nl >> 32);
p[sizeof(sha->p) - 6] = (uint8_t)(sha->Nl >> 40);
p[sizeof(sha->p) - 7] = (uint8_t)(sha->Nl >> 48);
p[sizeof(sha->p) - 8] = (uint8_t)(sha->Nl >> 56);
p[sizeof(sha->p) - 9] = (uint8_t)(sha->Nh);
p[sizeof(sha->p) - 10] = (uint8_t)(sha->Nh >> 8);
p[sizeof(sha->p) - 11] = (uint8_t)(sha->Nh >> 16);
p[sizeof(sha->p) - 12] = (uint8_t)(sha->Nh >> 24);
p[sizeof(sha->p) - 13] = (uint8_t)(sha->Nh >> 32);
p[sizeof(sha->p) - 14] = (uint8_t)(sha->Nh >> 40);
p[sizeof(sha->p) - 15] = (uint8_t)(sha->Nh >> 48);
p[sizeof(sha->p) - 16] = (uint8_t)(sha->Nh >> 56);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
sha512_block_data_order(sha->h, p, 1);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
if (out == NULL) {
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// TODO(davidben): This NULL check is absent in other low-level hash 'final'
// functions and is one of the few places one can fail.
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
return 0;
}
switch (sha->md_len) {
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// Let compiler decide if it's appropriate to unroll...
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
case SHA384_DIGEST_LENGTH:
for (n = 0; n < SHA384_DIGEST_LENGTH / 8; n++) {
uint64_t t = sha->h[n];
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
*(out++) = (uint8_t)(t >> 56);
*(out++) = (uint8_t)(t >> 48);
*(out++) = (uint8_t)(t >> 40);
*(out++) = (uint8_t)(t >> 32);
*(out++) = (uint8_t)(t >> 24);
*(out++) = (uint8_t)(t >> 16);
*(out++) = (uint8_t)(t >> 8);
*(out++) = (uint8_t)(t);
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
}
break;
case SHA512_DIGEST_LENGTH:
for (n = 0; n < SHA512_DIGEST_LENGTH / 8; n++) {
uint64_t t = sha->h[n];
Rename 'md' output parameter to 'out' and add bounds. We usually name output parameters 'out'. (Someone made a C++ templating change in Chromium which messed up const-ness, saw the compile error, and thought it was in MD5_Final.) Also tag the parameters with the sizes. Sadly, there's a bit of goofiness around SHA224_Final/SHA256_Final and SHA384_Final/SHA512_Final, but they're just documentation anyway. (Though it does touch on the mess that is sha->md_len which would be nice to clear through somehow.) Change-Id: I1918b7eecfe13f13b217d01d4414ac2358802354 Reviewed-on: https://boringssl-review.googlesource.com/c/boringssl/+/35484 Commit-Queue: David Benjamin <davidben@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-04-05 01:54:25 +01:00
*(out++) = (uint8_t)(t >> 56);
*(out++) = (uint8_t)(t >> 48);
*(out++) = (uint8_t)(t >> 40);
*(out++) = (uint8_t)(t >> 32);
*(out++) = (uint8_t)(t >> 24);
*(out++) = (uint8_t)(t >> 16);
*(out++) = (uint8_t)(t >> 8);
*(out++) = (uint8_t)(t);
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
}
break;
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// ... as well as make sure md_len is not abused.
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
default:
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// TODO(davidben): This bad |md_len| case is one of the few places a
// low-level hash 'final' function can fail. This should never happen.
Revert md_len removal from SHA256_CTX and SHA512_CTX. This reverts commits: - 91586371422dae70481c39752e55f01f50e9a93a - a90aa643024459c1698dbec84f4c79a3238b3db8 - c0d8b83b4462a0eb1889f32dbd7f46e83f4dbc81 It turns out code outside of BoringSSL also mismatches Init and Update/Final functions. Since this is largely cosmetic, it's probably not worth the cost to do this. Change-Id: I14e7b299172939f69ced2114be45ccba1dbbb704 Reviewed-on: https://boringssl-review.googlesource.com/7793 Reviewed-by: Adam Langley <agl@google.com>
2016-04-27 19:59:12 +01:00
return 0;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
return 1;
}
#ifndef SHA512_ASM
static const uint64_t K512[80] = {
Use UINT64_C in sha512.c table. From the naclports patch: https://chromium.googlesource.com/external/naclports/+/master/ports/boringssl/nacl.patch Change-Id: I37ad45fbde0b1b1437d3abd8ed7422bd72cfd959 Reviewed-on: https://boringssl-review.googlesource.com/6623 Reviewed-by: Adam Langley <agl@google.com>
2015-12-05 02:42:28 +00:00
UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd),
UINT64_C(0xb5c0fbcfec4d3b2f), UINT64_C(0xe9b5dba58189dbbc),
UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019),
UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118),
UINT64_C(0xd807aa98a3030242), UINT64_C(0x12835b0145706fbe),
UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2),
UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1),
UINT64_C(0x9bdc06a725c71235), UINT64_C(0xc19bf174cf692694),
UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3),
UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65),
UINT64_C(0x2de92c6f592b0275), UINT64_C(0x4a7484aa6ea6e483),
UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5),
UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210),
UINT64_C(0xb00327c898fb213f), UINT64_C(0xbf597fc7beef0ee4),
UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725),
UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70),
UINT64_C(0x27b70a8546d22ffc), UINT64_C(0x2e1b21385c26c926),
UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df),
UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8),
UINT64_C(0x81c2c92e47edaee6), UINT64_C(0x92722c851482353b),
UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001),
UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30),
UINT64_C(0xd192e819d6ef5218), UINT64_C(0xd69906245565a910),
UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8),
UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53),
UINT64_C(0x2748774cdf8eeb99), UINT64_C(0x34b0bcb5e19b48a8),
UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb),
UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3),
UINT64_C(0x748f82ee5defb2fc), UINT64_C(0x78a5636f43172f60),
UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec),
UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9),
UINT64_C(0xbef9a3f7b2c67915), UINT64_C(0xc67178f2e372532b),
UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207),
UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178),
UINT64_C(0x06f067aa72176fba), UINT64_C(0x0a637dc5a2c898a6),
UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b),
UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493),
UINT64_C(0x3c9ebe0a15c9bebc), UINT64_C(0x431d67c49c100d4c),
UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a),
UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817),
};
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#if defined(__GNUC__) && __GNUC__ >= 2 && !defined(OPENSSL_NO_ASM)
#if defined(__x86_64) || defined(__x86_64__)
Remove asm __asm__ define. It's only used in one file. No sense in polluting the namespace here. Change-Id: Iaf3870a4be2d2cad950f4d080e25fe7f0d3929c7 Reviewed-on: https://boringssl-review.googlesource.com/6660 Reviewed-by: Adam Langley <agl@google.com>
2015-12-07 19:26:45 +00:00
#define ROTR(a, n) \
({ \
uint64_t ret; \
__asm__("rorq %1, %0" : "=r"(ret) : "J"(n), "0"(a) : "cc"); \
ret; \
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
})
#elif(defined(_ARCH_PPC) && defined(__64BIT__)) || defined(_ARCH_PPC64)
Remove asm __asm__ define. It's only used in one file. No sense in polluting the namespace here. Change-Id: Iaf3870a4be2d2cad950f4d080e25fe7f0d3929c7 Reviewed-on: https://boringssl-review.googlesource.com/6660 Reviewed-by: Adam Langley <agl@google.com>
2015-12-07 19:26:45 +00:00
#define ROTR(a, n) \
({ \
uint64_t ret; \
__asm__("rotrdi %0, %1, %2" : "=r"(ret) : "r"(a), "K"(n)); \
ret; \
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
})
#elif defined(__aarch64__)
Remove asm __asm__ define. It's only used in one file. No sense in polluting the namespace here. Change-Id: Iaf3870a4be2d2cad950f4d080e25fe7f0d3929c7 Reviewed-on: https://boringssl-review.googlesource.com/6660 Reviewed-by: Adam Langley <agl@google.com>
2015-12-07 19:26:45 +00:00
#define ROTR(a, n) \
({ \
uint64_t ret; \
__asm__("ror %0, %1, %2" : "=r"(ret) : "r"(a), "I"(n)); \
ret; \
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
})
#endif
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
#elif defined(_MSC_VER) && defined(_WIN64)
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#pragma intrinsic(_rotr64)
#define ROTR(a, n) _rotr64((a), n)
#endif
#ifndef ROTR
#define ROTR(x, s) (((x) >> s) | (x) << (64 - s))
#endif
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
static inline uint64_t load_u64_be(const void *ptr) {
uint64_t ret;
OPENSSL_memcpy(&ret, ptr, sizeof(ret));
return CRYPTO_bswap8(ret);
}
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
#define Sigma0(x) (ROTR((x), 28) ^ ROTR((x), 34) ^ ROTR((x), 39))
#define Sigma1(x) (ROTR((x), 14) ^ ROTR((x), 18) ^ ROTR((x), 41))
#define sigma0(x) (ROTR((x), 1) ^ ROTR((x), 8) ^ ((x) >> 7))
#define sigma1(x) (ROTR((x), 19) ^ ROTR((x), 61) ^ ((x) >> 6))
#define Ch(x, y, z) (((x) & (y)) ^ ((~(x)) & (z)))
#define Maj(x, y, z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
#if defined(__i386) || defined(__i386__) || defined(_M_IX86)
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
// This code should give better results on 32-bit CPU with less than
// ~24 registers, both size and performance wise...
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
static void sha512_block_data_order(uint64_t *state, const uint8_t *in,
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
size_t num) {
uint64_t A, E, T;
uint64_t X[9 + 80], *F;
int i;
while (num--) {
F = X + 80;
Improve crypto/digest/md32_common.h mechanism. The documentation in md32_common.h is now (more) correct with respect to the most important details of the layout of |HASH_CTX|. The documentation explaining why sha512.c doesn't use md32_common.h is now more accurate as well. Before, the C implementations of HASH_BLOCK_DATA_ORDER took a pointer to the |HASH_CTX| and the assembly language implementations took a pointer to the hash state |h| member of |HASH_CTX|. (This worked because |h| is always the first member of |HASH_CTX|.) Now, the C implementations take a pointer directly to |h| too. The definitions of |MD4_CTX|, |MD5_CTX|, and |SHA1_CTX| were changed to be consistent with |SHA256_CTX| and |SHA512_CTX| in storing the hash state in an array. This will break source compatibility with any external code that accesses the hash state directly, but will not affect binary compatibility. The second parameter of |HASH_BLOCK_DATA_ORDER| is now of type |const uint8_t *|; previously it was |void *| and all implementations had a |uint8_t *data| variable to access it as an array of bytes. This change paves the way for future refactorings such as automatically generating the |*_Init| functions and/or sharing one I-U-F implementation across all digest algorithms. Change-Id: I6e9dd09ff057c67941021d324a4fa1d39f58b0db Reviewed-on: https://boringssl-review.googlesource.com/6405 Reviewed-by: Adam Langley <agl@google.com>
2015-11-01 20:13:24 +00:00
A = state[0];
F[1] = state[1];
F[2] = state[2];
F[3] = state[3];
E = state[4];
F[5] = state[5];
F[6] = state[6];
F[7] = state[7];
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
for (i = 0; i < 16; i++, F--) {
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T = load_u64_be(in + i * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A, F[1], F[2]);
}
for (; i < 80; i++, F--) {
T = sigma0(F[8 + 16 - 1]);
T += sigma1(F[8 + 16 - 14]);
T += F[8 + 16] + F[8 + 16 - 9];
F[0] = A;
F[4] = E;
F[8] = T;
T += F[7] + Sigma1(E) + Ch(E, F[5], F[6]) + K512[i];
E = F[3] + T;
A = T + Sigma0(A) + Maj(A, F[1], F[2]);
}
Improve crypto/digest/md32_common.h mechanism. The documentation in md32_common.h is now (more) correct with respect to the most important details of the layout of |HASH_CTX|. The documentation explaining why sha512.c doesn't use md32_common.h is now more accurate as well. Before, the C implementations of HASH_BLOCK_DATA_ORDER took a pointer to the |HASH_CTX| and the assembly language implementations took a pointer to the hash state |h| member of |HASH_CTX|. (This worked because |h| is always the first member of |HASH_CTX|.) Now, the C implementations take a pointer directly to |h| too. The definitions of |MD4_CTX|, |MD5_CTX|, and |SHA1_CTX| were changed to be consistent with |SHA256_CTX| and |SHA512_CTX| in storing the hash state in an array. This will break source compatibility with any external code that accesses the hash state directly, but will not affect binary compatibility. The second parameter of |HASH_BLOCK_DATA_ORDER| is now of type |const uint8_t *|; previously it was |void *| and all implementations had a |uint8_t *data| variable to access it as an array of bytes. This change paves the way for future refactorings such as automatically generating the |*_Init| functions and/or sharing one I-U-F implementation across all digest algorithms. Change-Id: I6e9dd09ff057c67941021d324a4fa1d39f58b0db Reviewed-on: https://boringssl-review.googlesource.com/6405 Reviewed-by: Adam Langley <agl@google.com>
2015-11-01 20:13:24 +00:00
state[0] += A;
state[1] += F[1];
state[2] += F[2];
state[3] += F[3];
state[4] += E;
state[5] += F[5];
state[6] += F[6];
state[7] += F[7];
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
in += 16 * 8;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
}
#else
#define ROUND_00_15(i, a, b, c, d, e, f, g, h) \
do { \
T1 += h + Sigma1(e) + Ch(e, f, g) + K512[i]; \
h = Sigma0(a) + Maj(a, b, c); \
d += T1; \
h += T1; \
} while (0)
#define ROUND_16_80(i, j, a, b, c, d, e, f, g, h, X) \
do { \
s0 = X[(j + 1) & 0x0f]; \
s0 = sigma0(s0); \
s1 = X[(j + 14) & 0x0f]; \
s1 = sigma1(s1); \
T1 = X[(j) & 0x0f] += s0 + s1 + X[(j + 9) & 0x0f]; \
ROUND_00_15(i + j, a, b, c, d, e, f, g, h); \
} while (0)
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
static void sha512_block_data_order(uint64_t *state, const uint8_t *in,
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
size_t num) {
uint64_t a, b, c, d, e, f, g, h, s0, s1, T1;
uint64_t X[16];
int i;
while (num--) {
Improve crypto/digest/md32_common.h mechanism. The documentation in md32_common.h is now (more) correct with respect to the most important details of the layout of |HASH_CTX|. The documentation explaining why sha512.c doesn't use md32_common.h is now more accurate as well. Before, the C implementations of HASH_BLOCK_DATA_ORDER took a pointer to the |HASH_CTX| and the assembly language implementations took a pointer to the hash state |h| member of |HASH_CTX|. (This worked because |h| is always the first member of |HASH_CTX|.) Now, the C implementations take a pointer directly to |h| too. The definitions of |MD4_CTX|, |MD5_CTX|, and |SHA1_CTX| were changed to be consistent with |SHA256_CTX| and |SHA512_CTX| in storing the hash state in an array. This will break source compatibility with any external code that accesses the hash state directly, but will not affect binary compatibility. The second parameter of |HASH_BLOCK_DATA_ORDER| is now of type |const uint8_t *|; previously it was |void *| and all implementations had a |uint8_t *data| variable to access it as an array of bytes. This change paves the way for future refactorings such as automatically generating the |*_Init| functions and/or sharing one I-U-F implementation across all digest algorithms. Change-Id: I6e9dd09ff057c67941021d324a4fa1d39f58b0db Reviewed-on: https://boringssl-review.googlesource.com/6405 Reviewed-by: Adam Langley <agl@google.com>
2015-11-01 20:13:24 +00:00
a = state[0];
b = state[1];
c = state[2];
d = state[3];
e = state[4];
f = state[5];
g = state[6];
h = state[7];
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[0] = load_u64_be(in);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(0, a, b, c, d, e, f, g, h);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[1] = load_u64_be(in + 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(1, h, a, b, c, d, e, f, g);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[2] = load_u64_be(in + 2 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(2, g, h, a, b, c, d, e, f);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[3] = load_u64_be(in + 3 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(3, f, g, h, a, b, c, d, e);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[4] = load_u64_be(in + 4 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(4, e, f, g, h, a, b, c, d);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[5] = load_u64_be(in + 5 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(5, d, e, f, g, h, a, b, c);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[6] = load_u64_be(in + 6 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(6, c, d, e, f, g, h, a, b);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[7] = load_u64_be(in + 7 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(7, b, c, d, e, f, g, h, a);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[8] = load_u64_be(in + 8 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(8, a, b, c, d, e, f, g, h);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[9] = load_u64_be(in + 9 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(9, h, a, b, c, d, e, f, g);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[10] = load_u64_be(in + 10 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(10, g, h, a, b, c, d, e, f);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[11] = load_u64_be(in + 11 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(11, f, g, h, a, b, c, d, e);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[12] = load_u64_be(in + 12 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(12, e, f, g, h, a, b, c, d);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[13] = load_u64_be(in + 13 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(13, d, e, f, g, h, a, b, c);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[14] = load_u64_be(in + 14 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(14, c, d, e, f, g, h, a, b);
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
T1 = X[15] = load_u64_be(in + 15 * 8);
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
ROUND_00_15(15, b, c, d, e, f, g, h, a);
for (i = 16; i < 80; i += 16) {
ROUND_16_80(i, 0, a, b, c, d, e, f, g, h, X);
ROUND_16_80(i, 1, h, a, b, c, d, e, f, g, X);
ROUND_16_80(i, 2, g, h, a, b, c, d, e, f, X);
ROUND_16_80(i, 3, f, g, h, a, b, c, d, e, X);
ROUND_16_80(i, 4, e, f, g, h, a, b, c, d, X);
ROUND_16_80(i, 5, d, e, f, g, h, a, b, c, X);
ROUND_16_80(i, 6, c, d, e, f, g, h, a, b, X);
ROUND_16_80(i, 7, b, c, d, e, f, g, h, a, X);
ROUND_16_80(i, 8, a, b, c, d, e, f, g, h, X);
ROUND_16_80(i, 9, h, a, b, c, d, e, f, g, X);
ROUND_16_80(i, 10, g, h, a, b, c, d, e, f, X);
ROUND_16_80(i, 11, f, g, h, a, b, c, d, e, X);
ROUND_16_80(i, 12, e, f, g, h, a, b, c, d, X);
ROUND_16_80(i, 13, d, e, f, g, h, a, b, c, X);
ROUND_16_80(i, 14, c, d, e, f, g, h, a, b, X);
ROUND_16_80(i, 15, b, c, d, e, f, g, h, a, X);
}
Improve crypto/digest/md32_common.h mechanism. The documentation in md32_common.h is now (more) correct with respect to the most important details of the layout of |HASH_CTX|. The documentation explaining why sha512.c doesn't use md32_common.h is now more accurate as well. Before, the C implementations of HASH_BLOCK_DATA_ORDER took a pointer to the |HASH_CTX| and the assembly language implementations took a pointer to the hash state |h| member of |HASH_CTX|. (This worked because |h| is always the first member of |HASH_CTX|.) Now, the C implementations take a pointer directly to |h| too. The definitions of |MD4_CTX|, |MD5_CTX|, and |SHA1_CTX| were changed to be consistent with |SHA256_CTX| and |SHA512_CTX| in storing the hash state in an array. This will break source compatibility with any external code that accesses the hash state directly, but will not affect binary compatibility. The second parameter of |HASH_BLOCK_DATA_ORDER| is now of type |const uint8_t *|; previously it was |void *| and all implementations had a |uint8_t *data| variable to access it as an array of bytes. This change paves the way for future refactorings such as automatically generating the |*_Init| functions and/or sharing one I-U-F implementation across all digest algorithms. Change-Id: I6e9dd09ff057c67941021d324a4fa1d39f58b0db Reviewed-on: https://boringssl-review.googlesource.com/6405 Reviewed-by: Adam Langley <agl@google.com>
2015-11-01 20:13:24 +00:00
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
state[5] += f;
state[6] += g;
state[7] += h;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
Fix undefined pointer casts in SHA-512 code. Casting an unaligned pointer to uint64_t* is undefined, even on platforms that support unaligned access. Additionally, dereferencing as uint64_t violates strict aliasing rules. Instead, use memcpys which we assume any sensible compiler can optimize. Also simplify the PULL64 business with the existing CRYPTO_bswap8. This also removes the need for the SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA logic. The generic C code now handles unaligned data and the assembly already can as well. (The only problematic platform with assembly is old ARM, but sha512-armv4.pl already handles this via an __ARM_ARCH__ check. See also OpenSSL's version of this file which always defines SHA512_BLOCK_CAN_MANAGE_UNALIGNED_DATA if SHA512_ASM is defined.) Add unaligned tests to digest_test.cc, so we retain coverage of unaligned EVP_MD inputs. Change-Id: Idfd8586c64bab2a77292af2fa8eebbd193e57c7d Reviewed-on: https://boringssl-review.googlesource.com/c/34444 Commit-Queue: Adam Langley <agl@google.com> Reviewed-by: Adam Langley <agl@google.com>
2019-01-12 18:43:18 +00:00
in += 16 * 8;
Inital import. Initial fork from f2d678e6e89b6508147086610e985d4e8416e867 (1.0.2 beta). (This change contains substantial changes from the original and effectively starts a new history.)
2014-06-20 20:00:00 +01:00
}
}
#endif
Run the comment converter on libcrypto. crypto/{asn1,x509,x509v3,pem} were skipped as they are still OpenSSL style. Change-Id: I3cd9a60e1cb483a981aca325041f3fbce294247c Reviewed-on: https://boringssl-review.googlesource.com/19504 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: David Benjamin <davidben@google.com> CQ-Verified: CQ bot account: commit-bot@chromium.org <commit-bot@chromium.org>
2017-08-18 19:06:02 +01:00
#endif // !SHA512_ASM
First part of the FIPS module. Change-Id: Ic3a91ccd2c8cdc364740f256fdb8a7ff66177947 Reviewed-on: https://boringssl-review.googlesource.com/14506 Reviewed-by: Adam Langley <agl@google.com> Commit-Queue: Adam Langley <agl@google.com>
2017-04-04 22:21:43 +01:00
#undef ROTR
#undef Sigma0
#undef Sigma1
#undef sigma0
#undef sigma1
#undef Ch
#undef Maj
#undef ROUND_00_15
#undef ROUND_16_80
Reference in New Issue Copy Permalink