|
@@ -3,6 +3,7 @@
|
|
|
* AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/
|
|
|
*
|
|
|
* Copyright (c) 2000-2001, Aaron D. Gifford
|
|
|
+ * Copyright (c) 2015, DiUS Computing Pty Ltd (jmattsson@dius.com.au)
|
|
|
* All rights reserved.
|
|
|
*
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
@@ -31,9 +32,11 @@
|
|
|
*
|
|
|
*/
|
|
|
|
|
|
-#include <string.h> /* memcpy()/memset() or bcopy()/bzero() */
|
|
|
-#include <assert.h> /* assert() */
|
|
|
+#ifndef WITHOUT_SHA2
|
|
|
+
|
|
|
#include "sha2.h"
|
|
|
+#include <string.h> /* memcpy()/memset() or bcopy()/bzero() */
|
|
|
+#define assert(x) do {} while (0)
|
|
|
|
|
|
/*
|
|
|
* ASSERT NOTE:
|
|
@@ -56,76 +59,19 @@
|
|
|
*/
|
|
|
|
|
|
|
|
|
-/*** SHA-256/384/512 Machine Architecture Definitions *****************/
|
|
|
-/*
|
|
|
- * BYTE_ORDER NOTE:
|
|
|
- *
|
|
|
- * Please make sure that your system defines BYTE_ORDER. If your
|
|
|
- * architecture is little-endian, make sure it also defines
|
|
|
- * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
|
|
|
- * equivilent.
|
|
|
- *
|
|
|
- * If your system does not define the above, then you can do so by
|
|
|
- * hand like this:
|
|
|
- *
|
|
|
- * #define LITTLE_ENDIAN 1234
|
|
|
- * #define BIG_ENDIAN 4321
|
|
|
- *
|
|
|
- * And for little-endian machines, add:
|
|
|
- *
|
|
|
- * #define BYTE_ORDER LITTLE_ENDIAN
|
|
|
- *
|
|
|
- * Or for big-endian machines:
|
|
|
- *
|
|
|
- * #define BYTE_ORDER BIG_ENDIAN
|
|
|
- *
|
|
|
- * The FreeBSD machine this was written on defines BYTE_ORDER
|
|
|
- * appropriately by including <sys/types.h> (which in turn includes
|
|
|
- * <machine/endian.h> where the appropriate definitions are actually
|
|
|
- * made).
|
|
|
- */
|
|
|
-#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
|
|
|
-#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
|
|
|
-#endif
|
|
|
-
|
|
|
-/*
|
|
|
- * Define the followingsha2_* types to types of the correct length on
|
|
|
- * the native archtecture. Most BSD systems and Linux define u_intXX_t
|
|
|
- * types. Machines with very recent ANSI C headers, can use the
|
|
|
- * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H
|
|
|
- * during compile or in the sha.h header file.
|
|
|
- *
|
|
|
- * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t
|
|
|
- * will need to define these three typedefs below (and the appropriate
|
|
|
- * ones in sha.h too) by hand according to their system architecture.
|
|
|
- *
|
|
|
- * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t
|
|
|
- * types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
|
|
|
- */
|
|
|
-#ifdef SHA2_USE_INTTYPES_H
|
|
|
-
|
|
|
typedef uint8_t sha2_byte; /* Exactly 1 byte */
|
|
|
typedef uint32_t sha2_word32; /* Exactly 4 bytes */
|
|
|
typedef uint64_t sha2_word64; /* Exactly 8 bytes */
|
|
|
|
|
|
-#else /* SHA2_USE_INTTYPES_H */
|
|
|
-
|
|
|
-typedef u_int8_t sha2_byte; /* Exactly 1 byte */
|
|
|
-typedef u_int32_t sha2_word32; /* Exactly 4 bytes */
|
|
|
-typedef u_int64_t sha2_word64; /* Exactly 8 bytes */
|
|
|
-
|
|
|
-#endif /* SHA2_USE_INTTYPES_H */
|
|
|
-
|
|
|
|
|
|
/*** SHA-256/384/512 Various Length Definitions ***********************/
|
|
|
-/* NOTE: Most of these are in sha2.h */
|
|
|
#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8)
|
|
|
#define SHA384_SHORT_BLOCK_LENGTH (SHA384_BLOCK_LENGTH - 16)
|
|
|
#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16)
|
|
|
|
|
|
|
|
|
/*** ENDIAN REVERSAL MACROS *******************************************/
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
#define REVERSE32(w,x) { \
|
|
|
sha2_word32 tmp = (w); \
|
|
|
tmp = (tmp >> 16) | (tmp << 16); \
|
|
@@ -139,7 +85,7 @@ typedef u_int64_t sha2_word64; /* Exactly 8 bytes */
|
|
|
(x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
|
|
|
((tmp & 0x0000ffff0000ffffULL) << 16); \
|
|
|
}
|
|
|
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ */
|
|
|
|
|
|
/*
|
|
|
* Macro for incrementally adding the unsigned 64-bit integer n to the
|
|
@@ -324,15 +270,9 @@ const static sha2_word64 sha512_initial_hash_value[8] = {
|
|
|
0x5be0cd19137e2179ULL
|
|
|
};
|
|
|
|
|
|
-/*
|
|
|
- * Constant used by SHA256/384/512_End() functions for converting the
|
|
|
- * digest to a readable hexadecimal character string:
|
|
|
- */
|
|
|
-static const char *sha2_hex_digits = "0123456789abcdef";
|
|
|
-
|
|
|
|
|
|
/*** SHA-256: *********************************************************/
|
|
|
-void SHA256_Init(SHA256_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA256_Init(SHA256_CTX* context) {
|
|
|
if (context == (SHA256_CTX*)0) {
|
|
|
return;
|
|
|
}
|
|
@@ -345,7 +285,7 @@ void SHA256_Init(SHA256_CTX* context) {
|
|
|
|
|
|
/* Unrolled SHA-256 round macros: */
|
|
|
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_
|
|
|
|
|
|
#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
|
REVERSE32(*data++, W256[j]); \
|
|
@@ -356,7 +296,7 @@ void SHA256_Init(SHA256_CTX* context) {
|
|
|
j++
|
|
|
|
|
|
|
|
|
-#else /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#else /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
|
|
|
#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
|
T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
|
|
@@ -365,7 +305,7 @@ void SHA256_Init(SHA256_CTX* context) {
|
|
|
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
|
|
|
j++
|
|
|
|
|
|
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
|
|
|
#define ROUND256(a,b,c,d,e,f,g,h) \
|
|
|
s0 = W256[(j+1)&0x0f]; \
|
|
@@ -378,7 +318,7 @@ void SHA256_Init(SHA256_CTX* context) {
|
|
|
(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
|
|
|
j++
|
|
|
|
|
|
-void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
+void ICACHE_FLASH_ATTR SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
|
|
|
sha2_word32 T1, *W256;
|
|
|
int j;
|
|
@@ -436,7 +376,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
|
|
|
#else /* SHA2_UNROLL_TRANSFORM */
|
|
|
|
|
|
-void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
+void ICACHE_FLASH_ATTR SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
sha2_word32 a, b, c, d, e, f, g, h, s0, s1;
|
|
|
sha2_word32 T1, T2, *W256;
|
|
|
int j;
|
|
@@ -455,15 +395,15 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
|
|
|
j = 0;
|
|
|
do {
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
/* Copy data while converting to host byte order */
|
|
|
REVERSE32(*data++,W256[j]);
|
|
|
/* Apply the SHA-256 compression function to update a..h */
|
|
|
T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
|
|
|
-#else /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#else /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
/* Apply the SHA-256 compression function to update a..h with copy */
|
|
|
T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
|
|
|
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
T2 = Sigma0_256(a) + Maj(a, b, c);
|
|
|
h = g;
|
|
|
g = f;
|
|
@@ -516,7 +456,7 @@ void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) {
|
|
|
|
|
|
#endif /* SHA2_UNROLL_TRANSFORM */
|
|
|
|
|
|
-void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
+void ICACHE_FLASH_ATTR SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
unsigned int freespace, usedspace;
|
|
|
|
|
|
if (len == 0) {
|
|
@@ -564,7 +504,7 @@ void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
usedspace = freespace = 0;
|
|
|
}
|
|
|
|
|
|
-void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
|
|
|
sha2_word32 *d = (sha2_word32*)digest;
|
|
|
unsigned int usedspace;
|
|
|
|
|
@@ -574,7 +514,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
|
|
|
/* If no digest buffer is passed, we don't bother doing this: */
|
|
|
if (digest != (sha2_byte*)0) {
|
|
|
usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
/* Convert FROM host byte order */
|
|
|
REVERSE64(context->bitcount,context->bitcount);
|
|
|
#endif
|
|
@@ -608,7 +548,7 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
|
|
|
/* Final transform: */
|
|
|
SHA256_Transform(context, (sha2_word32*)context->buffer);
|
|
|
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
{
|
|
|
/* Convert TO host byte order */
|
|
|
int j;
|
|
@@ -627,40 +567,9 @@ void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) {
|
|
|
usedspace = 0;
|
|
|
}
|
|
|
|
|
|
-char *SHA256_End(SHA256_CTX* context, char buffer[]) {
|
|
|
- sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest;
|
|
|
- int i;
|
|
|
-
|
|
|
- /* Sanity check: */
|
|
|
- assert(context != (SHA256_CTX*)0);
|
|
|
-
|
|
|
- if (buffer != (char*)0) {
|
|
|
- SHA256_Final(digest, context);
|
|
|
-
|
|
|
- for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
|
|
|
- *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
|
- *buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
|
- d++;
|
|
|
- }
|
|
|
- *buffer = (char)0;
|
|
|
- } else {
|
|
|
- MEMSET_BZERO(context, sizeof(SHA256_CTX));
|
|
|
- }
|
|
|
- MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
|
|
|
- return buffer;
|
|
|
-}
|
|
|
-
|
|
|
-char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
|
|
|
- SHA256_CTX context;
|
|
|
-
|
|
|
- SHA256_Init(&context);
|
|
|
- SHA256_Update(&context, data, len);
|
|
|
- return SHA256_End(&context, digest);
|
|
|
-}
|
|
|
-
|
|
|
|
|
|
/*** SHA-512: *********************************************************/
|
|
|
-void SHA512_Init(SHA512_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Init(SHA512_CTX* context) {
|
|
|
if (context == (SHA512_CTX*)0) {
|
|
|
return;
|
|
|
}
|
|
@@ -672,7 +581,7 @@ void SHA512_Init(SHA512_CTX* context) {
|
|
|
#ifdef SHA2_UNROLL_TRANSFORM
|
|
|
|
|
|
/* Unrolled SHA-512 round macros: */
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_
|
|
|
|
|
|
#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
|
REVERSE64(*data++, W512[j]); \
|
|
@@ -683,7 +592,7 @@ void SHA512_Init(SHA512_CTX* context) {
|
|
|
j++
|
|
|
|
|
|
|
|
|
-#else /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#else /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
|
|
|
#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \
|
|
|
T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
|
|
@@ -692,7 +601,7 @@ void SHA512_Init(SHA512_CTX* context) {
|
|
|
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
|
|
|
j++
|
|
|
|
|
|
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
|
|
|
#define ROUND512(a,b,c,d,e,f,g,h) \
|
|
|
s0 = W512[(j+1)&0x0f]; \
|
|
@@ -705,7 +614,7 @@ void SHA512_Init(SHA512_CTX* context) {
|
|
|
(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
|
|
|
j++
|
|
|
|
|
|
-void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
|
|
|
sha2_word64 T1, *W512 = (sha2_word64*)context->buffer;
|
|
|
int j;
|
|
@@ -760,7 +669,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
|
|
|
#else /* SHA2_UNROLL_TRANSFORM */
|
|
|
|
|
|
-void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
sha2_word64 a, b, c, d, e, f, g, h, s0, s1;
|
|
|
sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer;
|
|
|
int j;
|
|
@@ -777,15 +686,15 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
|
|
|
j = 0;
|
|
|
do {
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
/* Convert TO host byte order */
|
|
|
REVERSE64(*data++, W512[j]);
|
|
|
/* Apply the SHA-512 compression function to update a..h */
|
|
|
T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
|
|
|
-#else /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#else /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
/* Apply the SHA-512 compression function to update a..h with copy */
|
|
|
T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
|
|
|
-#endif /* BYTE_ORDER == LITTLE_ENDIAN */
|
|
|
+#endif /* __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN_ */
|
|
|
T2 = Sigma0_512(a) + Maj(a, b, c);
|
|
|
h = g;
|
|
|
g = f;
|
|
@@ -838,7 +747,7 @@ void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) {
|
|
|
|
|
|
#endif /* SHA2_UNROLL_TRANSFORM */
|
|
|
|
|
|
-void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
unsigned int freespace, usedspace;
|
|
|
|
|
|
if (len == 0) {
|
|
@@ -886,11 +795,11 @@ void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) {
|
|
|
usedspace = freespace = 0;
|
|
|
}
|
|
|
|
|
|
-void SHA512_Last(SHA512_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Last(SHA512_CTX* context) {
|
|
|
unsigned int usedspace;
|
|
|
|
|
|
usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
/* Convert FROM host byte order */
|
|
|
REVERSE64(context->bitcount[0],context->bitcount[0]);
|
|
|
REVERSE64(context->bitcount[1],context->bitcount[1]);
|
|
@@ -927,7 +836,7 @@ void SHA512_Last(SHA512_CTX* context) {
|
|
|
SHA512_Transform(context, (sha2_word64*)context->buffer);
|
|
|
}
|
|
|
|
|
|
-void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
|
|
|
sha2_word64 *d = (sha2_word64*)digest;
|
|
|
|
|
|
/* Sanity check: */
|
|
@@ -938,7 +847,7 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
|
|
|
SHA512_Last(context);
|
|
|
|
|
|
/* Save the hash data for output: */
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
{
|
|
|
/* Convert TO host byte order */
|
|
|
int j;
|
|
@@ -956,40 +865,9 @@ void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) {
|
|
|
MEMSET_BZERO(context, sizeof(SHA512_CTX));
|
|
|
}
|
|
|
|
|
|
-char *SHA512_End(SHA512_CTX* context, char buffer[]) {
|
|
|
- sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest;
|
|
|
- int i;
|
|
|
-
|
|
|
- /* Sanity check: */
|
|
|
- assert(context != (SHA512_CTX*)0);
|
|
|
-
|
|
|
- if (buffer != (char*)0) {
|
|
|
- SHA512_Final(digest, context);
|
|
|
-
|
|
|
- for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
|
|
|
- *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
|
- *buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
|
- d++;
|
|
|
- }
|
|
|
- *buffer = (char)0;
|
|
|
- } else {
|
|
|
- MEMSET_BZERO(context, sizeof(SHA512_CTX));
|
|
|
- }
|
|
|
- MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
|
|
|
- return buffer;
|
|
|
-}
|
|
|
-
|
|
|
-char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
|
|
|
- SHA512_CTX context;
|
|
|
-
|
|
|
- SHA512_Init(&context);
|
|
|
- SHA512_Update(&context, data, len);
|
|
|
- return SHA512_End(&context, digest);
|
|
|
-}
|
|
|
-
|
|
|
|
|
|
/*** SHA-384: *********************************************************/
|
|
|
-void SHA384_Init(SHA384_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA384_Init(SHA384_CTX* context) {
|
|
|
if (context == (SHA384_CTX*)0) {
|
|
|
return;
|
|
|
}
|
|
@@ -998,11 +876,11 @@ void SHA384_Init(SHA384_CTX* context) {
|
|
|
context->bitcount[0] = context->bitcount[1] = 0;
|
|
|
}
|
|
|
|
|
|
-void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
|
|
|
+void ICACHE_FLASH_ATTR SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) {
|
|
|
SHA512_Update((SHA512_CTX*)context, data, len);
|
|
|
}
|
|
|
|
|
|
-void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
|
|
|
+void ICACHE_FLASH_ATTR SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
|
|
|
sha2_word64 *d = (sha2_word64*)digest;
|
|
|
|
|
|
/* Sanity check: */
|
|
@@ -1013,7 +891,7 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
|
|
|
SHA512_Last((SHA512_CTX*)context);
|
|
|
|
|
|
/* Save the hash data for output: */
|
|
|
-#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
|
|
|
{
|
|
|
/* Convert TO host byte order */
|
|
|
int j;
|
|
@@ -1031,34 +909,4 @@ void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) {
|
|
|
MEMSET_BZERO(context, sizeof(SHA384_CTX));
|
|
|
}
|
|
|
|
|
|
-char *SHA384_End(SHA384_CTX* context, char buffer[]) {
|
|
|
- sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest;
|
|
|
- int i;
|
|
|
-
|
|
|
- /* Sanity check: */
|
|
|
- assert(context != (SHA384_CTX*)0);
|
|
|
-
|
|
|
- if (buffer != (char*)0) {
|
|
|
- SHA384_Final(digest, context);
|
|
|
-
|
|
|
- for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
|
|
|
- *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
|
|
|
- *buffer++ = sha2_hex_digits[*d & 0x0f];
|
|
|
- d++;
|
|
|
- }
|
|
|
- *buffer = (char)0;
|
|
|
- } else {
|
|
|
- MEMSET_BZERO(context, sizeof(SHA384_CTX));
|
|
|
- }
|
|
|
- MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
|
|
|
- return buffer;
|
|
|
-}
|
|
|
-
|
|
|
-char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
|
|
|
- SHA384_CTX context;
|
|
|
-
|
|
|
- SHA384_Init(&context);
|
|
|
- SHA384_Update(&context, data, len);
|
|
|
- return SHA384_End(&context, digest);
|
|
|
-}
|
|
|
-
|
|
|
+#endif // WITHOUT_SHA2
|