misc-deps
/
hmac_sha256
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Format code using clang-format 

Use malloc instead of VLAs (C99). Fixes #3
This commit is contained in:
h5p9sl 2021-08-18 16:39:37 -06:00
parent 197a2b309a
commit 4189b1de64
7 changed files with 410 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format Normal file
View File

@ -0,0 +1,2 @@
BasedOnStyle: Chromium
Standard: Cpp11

53
examples/simple_example.cpp
View File

@ -1,43 +1,38 @@
#include "../hmac_sha256.h" #include "../hmac_sha256.h"
#include <vector> #include <cassert>
#include <string> #include <iomanip>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <iomanip> #include <string>
#include <cassert> #include <vector>
#define SHA256_HASH_SIZE 32 #define SHA256_HASH_SIZE 32
int main() { int main() {
const std::string str_data = "Hello World!"; const std::string str_data = "Hello World!";
const std::string str_key = "super-secret-key"; const std::string str_key = "super-secret-key";
std::stringstream ss_result; std::stringstream ss_result;
// Allocate memory for the HMAC // Allocate memory for the HMAC
std::vector<uint8_t> out(SHA256_HASH_SIZE); std::vector<uint8_t> out(SHA256_HASH_SIZE);
// Call hmac-sha256 function // Call hmac-sha256 function
hmac_sha256( hmac_sha256(str_key.data(), str_key.size(), str_data.data(), str_data.size(),
str_key.data(), str_key.size(), out.data(), out.size());
str_data.data(), str_data.size(),
out.data(), out.size()
);
// Convert `out` to string with std::hex // Convert `out` to string with std::hex
for (uint8_t x : out) { for (uint8_t x : out) {
ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x; ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;
} }
// Print out the result // Print out the result
std::cout << "Message: " << str_data << std::endl; std::cout << "Message: " << str_data << std::endl;
std::cout << "Key: " << str_key << std::endl; std::cout << "Key: " << str_key << std::endl;
std::cout << "HMAC: " << ss_result.str() << std::endl; std::cout << "HMAC: " << ss_result.str() << std::endl;
// This assertion fails if something went wrong // This assertion fails if something went wrong
assert( assert(ss_result.str() ==
ss_result.str() == "4b393abced1c497f8048860ba1ede46a23f1ff5209b18e9c428bddfbb690aad8");
"4b393abced1c497f8048860ba1ede46a23f1ff5209b18e9c428bddfbb690aad8" return 0;
);
return 0;
} }

172
examples/tests.cpp
View File

@ -10,79 +10,119 @@
#define SHA256_HASH_SIZE 32 #define SHA256_HASH_SIZE 32
typedef std::vector<std::tuple<std::string, std::string, std::string>> TestData_t; typedef std::vector<std::tuple<std::string, std::string, std::string>>
TestData_t;
static void verify_result(const std::vector<uint8_t>& result, const std::string& expected) { static void verify_result(const std::vector<uint8_t>& result,
std::stringstream ss; const std::string& expected) {
for (uint8_t i : result) { ss << std::hex << std::setfill('0') << std::setw(2) << (int)i; } std::stringstream ss;
if (expected != ss.str()) { for (uint8_t i : result) {
std::cout << "*** TEST FAILED ***: \n\t" << ss.str() << " != \n\t" << expected << std::endl; ss << std::hex << std::setfill('0') << std::setw(2) << (int)i;
} else { }
std::cout << "Test successful" << std::endl; if (expected != ss.str()) {
} std::cout << "*** TEST FAILED ***: \n\t" << ss.str() << " != \n\t"
<< expected << std::endl;
} else {
std::cout << "Test successful" << std::endl;
}
} }
static void do_tests(const TestData_t& test_vectors) { static void do_tests(const TestData_t& test_vectors) {
for (auto tvec : test_vectors) { for (auto tvec : test_vectors) {
std::vector<uint8_t> out( std::vector<uint8_t> out(std::get<2>(tvec).size() / 2);
std::get<2>(tvec).size() / 2
);
hmac_sha256( hmac_sha256(std::get<0>(tvec).data(), std::get<0>(tvec).size(),
std::get<0>(tvec).data(), std::get<0>(tvec).size(), std::get<1>(tvec).data(), std::get<1>(tvec).size(), out.data(),
std::get<1>(tvec).data(), std::get<1>(tvec).size(), out.size());
out.data(), out.size()
);
verify_result(out, std::get<2>(tvec)); verify_result(out, std::get<2>(tvec));
} }
} }
int main() { int main() {
// Test vectors from RFC4231, https://tools.ietf.org/html/rfc4231#section-4 // Test vectors from RFC4231, https://tools.ietf.org/html/rfc4231#section-4
const TestData_t test_vectors = { const TestData_t test_vectors = {
// Key Data HMAC // Key Data HMAC
{ {
"\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b", "\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b\x0b"
"\x48\x69\x20\x54\x68\x65\x72\x65", "\x0b\x0b\x0b",
"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7", "\x48\x69\x20\x54\x68\x65\x72\x65",
}, { "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
/* Test with a key shorter than the length of the HMAC output. */ },
"\x4a\x65\x66\x65", {
"\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74\x20\x66\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f", /* Test with a key shorter than the length of the HMAC output. */
"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843", "\x4a\x65\x66\x65",
}, { "\x77\x68\x61\x74\x20\x64\x6f\x20\x79\x61\x20\x77\x61\x6e\x74\x20\x66"
/* Test with a combined length of key and data that is larger than 64 "\x6f\x72\x20\x6e\x6f\x74\x68\x69\x6e\x67\x3f",
bytes (= block-size of SHA-224 and SHA-256). */ "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa", },
"\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd", {
"773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe", /* Test with a combined length of key and data that is larger than 64
}, { bytes (= block-size of SHA-224 and SHA-256). */
/* Test with a combined length of key and data that is larger than 64 "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
bytes (= block-size of SHA-224 and SHA-256). */ "\xaa\xaa\xaa",
"\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19", "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
"\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd", "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd"
"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b", "\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd\xdd",
}, { "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
/* Test with a truncation of output to 128 bits. */ },
"\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c", {
"\x54\x65\x73\x74\x20\x57\x69\x74\x68\x20\x54\x72\x75\x6e\x63\x61\x74\x69\x6f\x6e", /* Test with a combined length of key and data that is larger than 64
"a3b6167473100ee06e0c796c2955552b", bytes (= block-size of SHA-224 and SHA-256). */
}, { "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11"
/* Test with a key larger than 128 bytes (= block-size of SHA-384 and "\x12\x13\x14\x15\x16\x17\x18\x19",
SHA-512). */ "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa", "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd"
"\x54\x65\x73\x74\x20\x55\x73\x69\x6e\x67\x20\x4c\x61\x72\x67\x65\x72\x20\x54\x68\x61\x6e\x20\x42\x6c\x6f\x63\x6b\x2d\x53\x69\x7a\x65\x20\x4b\x65\x79\x20\x2d\x20\x48\x61\x73\x68\x20\x4b\x65\x79\x20\x46\x69\x72\x73\x74", "\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd\xcd",
"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54", "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
}, { },
/* Test with a key and data that is larger than 128 bytes (= block-size {
of SHA-384 and SHA-512). */ /* Test with a truncation of output to 128 bits. */
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa", "\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c\x0c"
"\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20\x75\x73\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x6b\x65\x79\x20\x61\x6e\x64\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20\x54\x68\x65\x20\x6b\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20\x62\x65\x20\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20\x62\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68\x65\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x2e", "\x0c\x0c\x0c",
"9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2", "\x54\x65\x73\x74\x20\x57\x69\x74\x68\x20\x54\x72\x75\x6e\x63\x61\x74"
} "\x69\x6f\x6e",
}; "a3b6167473100ee06e0c796c2955552b",
do_tests(test_vectors); },
return 0; {
/* Test with a key larger than 128 bytes (= block-size of SHA-384 and
SHA-512). */
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
"\x54\x65\x73\x74\x20\x55\x73\x69\x6e\x67\x20\x4c\x61\x72\x67\x65\x72"
"\x20\x54\x68\x61\x6e\x20\x42\x6c\x6f\x63\x6b\x2d\x53\x69\x7a\x65\x20"
"\x4b\x65\x79\x20\x2d\x20\x48\x61\x73\x68\x20\x4b\x65\x79\x20\x46\x69"
"\x72\x73\x74",
"60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
},
{
/* Test with a key and data that is larger than 128 bytes (=
block-size of SHA-384 and SHA-512). */
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa",
"\x54\x68\x69\x73\x20\x69\x73\x20\x61\x20\x74\x65\x73\x74\x20\x75\x73"
"\x69\x6e\x67\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e"
"\x20\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x6b\x65\x79\x20\x61"
"\x6e\x64\x20\x61\x20\x6c\x61\x72\x67\x65\x72\x20\x74\x68\x61\x6e\x20"
"\x62\x6c\x6f\x63\x6b\x2d\x73\x69\x7a\x65\x20\x64\x61\x74\x61\x2e\x20"
"\x54\x68\x65\x20\x6b\x65\x79\x20\x6e\x65\x65\x64\x73\x20\x74\x6f\x20"
"\x62\x65\x20\x68\x61\x73\x68\x65\x64\x20\x62\x65\x66\x6f\x72\x65\x20"
"\x62\x65\x69\x6e\x67\x20\x75\x73\x65\x64\x20\x62\x79\x20\x74\x68\x65"
"\x20\x48\x4d\x41\x43\x20\x61\x6c\x67\x6f\x72\x69\x74\x68\x6d\x2e",
"9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
}};
do_tests(test_vectors);
return 0;
} }

137
hmac_sha256.c
View File

@ -15,84 +15,91 @@
/* LOCAL FUNCTIONS */ /* LOCAL FUNCTIONS */
// Concatenate X & Y, return hash. // Concatenate X & Y, return hash.
static void* H(const void *x, const size_t xlen, static void* H(const void* x,
const void *y, const size_t ylen, const size_t xlen,
void *out, const size_t outlen const void* y,
); const size_t ylen,
void* out,
const size_t outlen);
// Wrapper for sha256 // Wrapper for sha256
static void* sha256(const void *data, const size_t datalen, static void* sha256(const void* data,
void *out, const size_t outlen const size_t datalen,
); void* out,
const size_t outlen);
// Declared in hmac_sha256.h // Declared in hmac_sha256.h
size_t hmac_sha256(const void *key, const size_t keylen, size_t hmac_sha256(const void* key,
const void *data, const size_t datalen, const size_t keylen,
void *out, const size_t outlen) { const void* data,
uint8_t k[SHA256_BLOCK_SIZE]; const size_t datalen,
uint8_t k_ipad[SHA256_BLOCK_SIZE]; void* out,
uint8_t k_opad[SHA256_BLOCK_SIZE]; const size_t outlen) {
uint8_t ihash[SHA256_HASH_SIZE]; uint8_t k[SHA256_BLOCK_SIZE];
uint8_t ohash[SHA256_HASH_SIZE]; uint8_t k_ipad[SHA256_BLOCK_SIZE];
size_t sz; uint8_t k_opad[SHA256_BLOCK_SIZE];
int i; uint8_t ihash[SHA256_HASH_SIZE];
uint8_t ohash[SHA256_HASH_SIZE];
size_t sz;
int i;
memset(k, 0, SIZEOFARRAY(k)); memset(k, 0, SIZEOFARRAY(k));
memset(k_ipad, 0x36, SHA256_BLOCK_SIZE); memset(k_ipad, 0x36, SHA256_BLOCK_SIZE);
memset(k_opad, 0x5c, SHA256_BLOCK_SIZE); memset(k_opad, 0x5c, SHA256_BLOCK_SIZE);
if (keylen > SHA256_BLOCK_SIZE) { if (keylen > SHA256_BLOCK_SIZE) {
// If the key is larger than the hash algorithm's // If the key is larger than the hash algorithm's
// block size, we must digest it first. // block size, we must digest it first.
sha256(key, keylen, k, SIZEOFARRAY(k)); sha256(key, keylen, k, SIZEOFARRAY(k));
} else { } else {
memcpy(k, key, keylen); memcpy(k, key, keylen);
} }
for (i = 0; i < SHA256_BLOCK_SIZE; i++) { for (i = 0; i < SHA256_BLOCK_SIZE; i++) {
k_ipad[i] ^= k[i]; k_ipad[i] ^= k[i];
k_opad[i] ^= k[i]; k_opad[i] ^= k[i];
} }
// Perform HMAC algorithm: ( https://tools.ietf.org/html/rfc2104 ) // Perform HMAC algorithm: ( https://tools.ietf.org/html/rfc2104 )
// `H(K XOR opad, H(K XOR ipad, data))` // `H(K XOR opad, H(K XOR ipad, data))`
H(k_ipad, SIZEOFARRAY(k_ipad), H(k_ipad, SIZEOFARRAY(k_ipad), data, datalen, ihash, SIZEOFARRAY(ihash));
data, datalen, H(k_opad, SIZEOFARRAY(k_opad), ihash, SIZEOFARRAY(ihash), ohash,
ihash, SIZEOFARRAY(ihash) SIZEOFARRAY(ohash));
);
H(k_opad, SIZEOFARRAY(k_opad),
ihash, SIZEOFARRAY(ihash),
ohash, SIZEOFARRAY(ohash)
);
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen; sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
memcpy(out, ohash, sz); memcpy(out, ohash, sz);
return sz; return sz;
} }
static void* H(const void *x, const size_t xlen, static void* H(const void* x,
const void *y, const size_t ylen, const size_t xlen,
void *out, const size_t outlen const void* y,
) { const size_t ylen,
const size_t buflen = xlen + ylen; void* out,
uint8_t buf[buflen]; const size_t outlen) {
const size_t buflen = xlen + ylen;
uint8_t* buf = (uint8_t*)malloc(buflen);
void* result;
memcpy(buf, x, xlen); memcpy(buf, x, xlen);
memcpy(buf + xlen, y, ylen); memcpy(buf + xlen, y, ylen);
return sha256(buf, buflen * sizeof(uint8_t), out, outlen); result = sha256(buf, buflen, out, outlen);
free(buf);
return result;
} }
static void* sha256(const void *data, const size_t datalen, static void* sha256(const void* data,
void *out, const size_t outlen const size_t datalen,
) { void* out,
size_t sz; const size_t outlen) {
Sha256Context ctx; size_t sz;
SHA256_HASH hash; Sha256Context ctx;
SHA256_HASH hash;
Sha256Initialise(&ctx); Sha256Initialise(&ctx);
Sha256Update(&ctx, data, datalen); Sha256Update(&ctx, data, datalen);
Sha256Finalise(&ctx, &hash); Sha256Finalise(&ctx, &hash);
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen; sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
return memcpy(out, hash.bytes, sz); return memcpy(out, hash.bytes, sz);
} }

19
hmac_sha256.h
View File

@ -8,28 +8,29 @@
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif // __cplusplus #endif // __cplusplus
#include <stddef.h> #include <stddef.h>
size_t // Returns the number of bytes written to `out` size_t // Returns the number of bytes written to `out`
hmac_sha256( hmac_sha256(
// [in]: The key and its length. // [in]: The key and its length.
// Should be at least 32 bytes long for optimal security. // Should be at least 32 bytes long for optimal security.
const void* key, const size_t keylen, const void* key,
const size_t keylen,
// [in]: The data to hash alongside the key. // [in]: The data to hash alongside the key.
const void* data, const size_t datalen, const void* data,
const size_t datalen,
// [out]: The output hash. // [out]: The output hash.
// Should be 32 bytes long. If it's less than 32 bytes, // Should be 32 bytes long. If it's less than 32 bytes,
// the resulting hash will be truncated to the specified length. // the resulting hash will be truncated to the specified length.
void* out, const size_t outlen void* out,
); const size_t outlen);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif // __cplusplus #endif // __cplusplus
#endif // _HMAC_SHA256_H_
#endif // _HMAC_SHA256_H_

357
sha256.c
View File

@ -5,7 +5,8 @@
// Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org // Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org
// Modified by WaterJuice retaining Public Domain license. // Modified by WaterJuice retaining Public Domain license.
// //
// This is free and unencumbered software released into the public domain - June 2013 waterjuice.org // This is free and unencumbered software released into the public domain -
// June 2013 waterjuice.org
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -21,23 +22,33 @@
#define ror(value, bits) (((value) >> (bits)) | ((value) << (32 - (bits)))) #define ror(value, bits) (((value) >> (bits)) | ((value) << (32 - (bits))))
#define MIN(x, y) ( ((x)<(y))?(x):(y) ) #define MIN(x, y) (((x) < (y)) ? (x) : (y))
#define STORE32H(x, y) \ #define STORE32H(x, y) \
{ (y)[0] = (uint8_t)(((x)>>24)&255); (y)[1] = (uint8_t)(((x)>>16)&255); \ { \
(y)[2] = (uint8_t)(((x)>>8)&255); (y)[3] = (uint8_t)((x)&255); } (y)[0] = (uint8_t)(((x) >> 24) & 255); \
(y)[1] = (uint8_t)(((x) >> 16) & 255); \
(y)[2] = (uint8_t)(((x) >> 8) & 255); \
(y)[3] = (uint8_t)((x)&255); \
}
#define LOAD32H(x, y) \ #define LOAD32H(x, y) \
{ x = ((uint32_t)((y)[0] & 255)<<24) | \ { \
((uint32_t)((y)[1] & 255)<<16) | \ x = ((uint32_t)((y)[0] & 255) << 24) | ((uint32_t)((y)[1] & 255) << 16) | \
((uint32_t)((y)[2] & 255)<<8) | \ ((uint32_t)((y)[2] & 255) << 8) | ((uint32_t)((y)[3] & 255)); \
((uint32_t)((y)[3] & 255)); } }
#define STORE64H(x, y) \ #define STORE64H(x, y) \
{ (y)[0] = (uint8_t)(((x)>>56)&255); (y)[1] = (uint8_t)(((x)>>48)&255); \ { \
(y)[2] = (uint8_t)(((x)>>40)&255); (y)[3] = (uint8_t)(((x)>>32)&255); \ (y)[0] = (uint8_t)(((x) >> 56) & 255); \
(y)[4] = (uint8_t)(((x)>>24)&255); (y)[5] = (uint8_t)(((x)>>16)&255); \ (y)[1] = (uint8_t)(((x) >> 48) & 255); \
(y)[6] = (uint8_t)(((x)>>8)&255); (y)[7] = (uint8_t)((x)&255); } (y)[2] = (uint8_t)(((x) >> 40) & 255); \
(y)[3] = (uint8_t)(((x) >> 32) & 255); \
(y)[4] = (uint8_t)(((x) >> 24) & 255); \
(y)[5] = (uint8_t)(((x) >> 16) & 255); \
(y)[6] = (uint8_t)(((x) >> 8) & 255); \
(y)[7] = (uint8_t)((x)&255); \
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// CONSTANTS // CONSTANTS
@ -57,89 +68,76 @@ static const uint32_t K[64] = {
0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, 0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL};
};
#define BLOCK_SIZE 64 #define BLOCK_SIZE 64
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// INTERNAL FUNCTIONS // INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Various logical functions // Various logical functions
#define Ch( x, y, z ) (z ^ (x & (y ^ z))) #define Ch(x, y, z) (z ^ (x & (y ^ z)))
#define Maj( x, y, z ) (((x | y) & z) | (x & y)) #define Maj(x, y, z) (((x | y) & z) | (x & y))
#define S( x, n ) ror((x),(n)) #define S(x, n) ror((x), (n))
#define R( x, n ) (((x)&0xFFFFFFFFUL)>>(n)) #define R(x, n) (((x)&0xFFFFFFFFUL) >> (n))
#define Sigma0( x ) (S(x, 2) ^ S(x, 13) ^ S(x, 22)) #define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
#define Sigma1( x ) (S(x, 6) ^ S(x, 11) ^ S(x, 25)) #define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
#define Gamma0( x ) (S(x, 7) ^ S(x, 18) ^ R(x, 3)) #define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
#define Gamma1( x ) (S(x, 17) ^ S(x, 19) ^ R(x, 10)) #define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
#define Sha256Round( a, b, c, d, e, f, g, h, i ) \ #define Sha256Round(a, b, c, d, e, f, g, h, i) \
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \ t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
t1 = Sigma0(a) + Maj(a, b, c); \ t1 = Sigma0(a) + Maj(a, b, c); \
d += t0; \ d += t0; \
h = t0 + t1; h = t0 + t1;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// TransformFunction // TransformFunction
// //
// Compress 512-bits // Compress 512-bits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static static void TransformFunction(Sha256Context* Context, uint8_t const* Buffer) {
void uint32_t S[8];
TransformFunction uint32_t W[64];
( uint32_t t0;
Sha256Context* Context, uint32_t t1;
uint8_t const* Buffer uint32_t t;
) int i;
{
uint32_t S[8];
uint32_t W[64];
uint32_t t0;
uint32_t t1;
uint32_t t;
int i;
// Copy state into S // Copy state into S
for( i=0; i<8; i++ ) for (i = 0; i < 8; i++) {
{ S[i] = Context->state[i];
S[i] = Context->state[i]; }
}
// Copy the state into 512-bits into W[0..15] // Copy the state into 512-bits into W[0..15]
for( i=0; i<16; i++ ) for (i = 0; i < 16; i++) {
{ LOAD32H(W[i], Buffer + (4 * i));
LOAD32H( W[i], Buffer + (4*i) ); }
}
// Fill W[16..63] // Fill W[16..63]
for( i=16; i<64; i++ ) for (i = 16; i < 64; i++) {
{ W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
W[i] = Gamma1( W[i-2]) + W[i-7] + Gamma0( W[i-15] ) + W[i-16]; }
}
// Compress // Compress
for( i=0; i<64; i++ ) for (i = 0; i < 64; i++) {
{ Sha256Round(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
Sha256Round( S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i ); t = S[7];
t = S[7]; S[7] = S[6];
S[7] = S[6]; S[6] = S[5];
S[6] = S[5]; S[5] = S[4];
S[5] = S[4]; S[4] = S[3];
S[4] = S[3]; S[3] = S[2];
S[3] = S[2]; S[2] = S[1];
S[2] = S[1]; S[1] = S[0];
S[1] = S[0]; S[0] = t;
S[0] = t; }
}
// Feedback // Feedback
for( i=0; i<8; i++ ) for (i = 0; i < 8; i++) {
{ Context->state[i] = Context->state[i] + S[i];
Context->state[i] = Context->state[i] + S[i]; }
}
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -151,144 +149,119 @@ void
// //
// Initialises a SHA256 Context. Use this to initialise/reset a context. // Initialises a SHA256 Context. Use this to initialise/reset a context.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Initialise(Sha256Context* Context // [out]
Sha256Initialise ) {
( Context->curlen = 0;
Sha256Context* Context // [out] Context->length = 0;
) Context->state[0] = 0x6A09E667UL;
{ Context->state[1] = 0xBB67AE85UL;
Context->curlen = 0; Context->state[2] = 0x3C6EF372UL;
Context->length = 0; Context->state[3] = 0xA54FF53AUL;
Context->state[0] = 0x6A09E667UL; Context->state[4] = 0x510E527FUL;
Context->state[1] = 0xBB67AE85UL; Context->state[5] = 0x9B05688CUL;
Context->state[2] = 0x3C6EF372UL; Context->state[6] = 0x1F83D9ABUL;
Context->state[3] = 0xA54FF53AUL; Context->state[7] = 0x5BE0CD19UL;
Context->state[4] = 0x510E527FUL;
Context->state[5] = 0x9B05688CUL;
Context->state[6] = 0x1F83D9ABUL;
Context->state[7] = 0x5BE0CD19UL;
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Update // Sha256Update
// //
// Adds data to the SHA256 context. This will process the data and update the internal state of the context. Keep on // Adds data to the SHA256 context. This will process the data and update the
// calling this function until all the data has been added. Then call Sha256Finalise to calculate the hash. // internal state of the context. Keep on calling this function until all the
// data has been added. Then call Sha256Finalise to calculate the hash.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Update(Sha256Context* Context, // [in out]
Sha256Update void const* Buffer, // [in]
( uint32_t BufferSize // [in]
Sha256Context* Context, // [in out] ) {
void const* Buffer, // [in] uint32_t n;
uint32_t BufferSize // [in]
)
{
uint32_t n;
if( Context->curlen > sizeof(Context->buf) ) if (Context->curlen > sizeof(Context->buf)) {
{ return;
return; }
}
while( BufferSize > 0 ) while (BufferSize > 0) {
{ if (Context->curlen == 0 && BufferSize >= BLOCK_SIZE) {
if( Context->curlen == 0 && BufferSize >= BLOCK_SIZE ) TransformFunction(Context, (uint8_t*)Buffer);
{ Context->length += BLOCK_SIZE * 8;
TransformFunction( Context, (uint8_t*)Buffer ); Buffer = (uint8_t*)Buffer + BLOCK_SIZE;
Context->length += BLOCK_SIZE * 8; BufferSize -= BLOCK_SIZE;
Buffer = (uint8_t*)Buffer + BLOCK_SIZE; } else {
BufferSize -= BLOCK_SIZE; n = MIN(BufferSize, (BLOCK_SIZE - Context->curlen));
} memcpy(Context->buf + Context->curlen, Buffer, (size_t)n);
else Context->curlen += n;
{ Buffer = (uint8_t*)Buffer + n;
n = MIN( BufferSize, (BLOCK_SIZE - Context->curlen) ); BufferSize -= n;
memcpy( Context->buf + Context->curlen, Buffer, (size_t)n ); if (Context->curlen == BLOCK_SIZE) {
Context->curlen += n; TransformFunction(Context, Context->buf);
Buffer = (uint8_t*)Buffer + n; Context->length += 8 * BLOCK_SIZE;
BufferSize -= n; Context->curlen = 0;
if( Context->curlen == BLOCK_SIZE ) }
{
TransformFunction( Context, Context->buf );
Context->length += 8*BLOCK_SIZE;
Context->curlen = 0;
}
}
} }
}
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Finalise // Sha256Finalise
// //
// Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). After // Performs the final calculation of the hash and returns the digest (32 byte
// calling this, Sha256Initialised must be used to reuse the context. // buffer containing 256bit hash). After calling this, Sha256Initialised must
// be used to reuse the context.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Finalise(Sha256Context* Context, // [in out]
Sha256Finalise SHA256_HASH* Digest // [out]
( ) {
Sha256Context* Context, // [in out] int i;
SHA256_HASH* Digest // [out]
)
{
int i;
if( Context->curlen >= sizeof(Context->buf) ) if (Context->curlen >= sizeof(Context->buf)) {
{ return;
return; }
// Increase the length of the message
Context->length += Context->curlen * 8;
// Append the '1' bit
Context->buf[Context->curlen++] = (uint8_t)0x80;
// if the length is currently above 56 bytes we append zeros
// then compress. Then we can fall back to padding zeros and length
// encoding like normal.
if (Context->curlen > 56) {
while (Context->curlen < 64) {
Context->buf[Context->curlen++] = (uint8_t)0;
} }
TransformFunction(Context, Context->buf);
Context->curlen = 0;
}
// Increase the length of the message // Pad up to 56 bytes of zeroes
Context->length += Context->curlen * 8; while (Context->curlen < 56) {
Context->buf[Context->curlen++] = (uint8_t)0;
}
// Append the '1' bit // Store length
Context->buf[Context->curlen++] = (uint8_t)0x80; STORE64H(Context->length, Context->buf + 56);
TransformFunction(Context, Context->buf);
// if the length is currently above 56 bytes we append zeros // Copy output
// then compress. Then we can fall back to padding zeros and length for (i = 0; i < 8; i++) {
// encoding like normal. STORE32H(Context->state[i], Digest->bytes + (4 * i));
if( Context->curlen > 56 ) }
{
while( Context->curlen < 64 )
{
Context->buf[Context->curlen++] = (uint8_t)0;
}
TransformFunction(Context, Context->buf);
Context->curlen = 0;
}
// Pad up to 56 bytes of zeroes
while( Context->curlen < 56 )
{
Context->buf[Context->curlen++] = (uint8_t)0;
}
// Store length
STORE64H( Context->length, Context->buf+56 );
TransformFunction( Context, Context->buf );
// Copy output
for( i=0; i<8; i++ )
{
STORE32H( Context->state[i], Digest->bytes+(4*i) );
}
} }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Calculate // Sha256Calculate
// //
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one function. Calculates the SHA256 hash of the // Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one
// buffer. // function. Calculates the SHA256 hash of the buffer.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Calculate(void const* Buffer, // [in]
Sha256Calculate uint32_t BufferSize, // [in]
( SHA256_HASH* Digest // [in]
void const* Buffer, // [in] ) {
uint32_t BufferSize, // [in] Sha256Context context;
SHA256_HASH* Digest // [in]
)
{
Sha256Context context;
Sha256Initialise( &context ); Sha256Initialise(&context);
Sha256Update( &context, Buffer, BufferSize ); Sha256Update(&context, Buffer, BufferSize);
Sha256Finalise( &context, Digest ); Sha256Finalise(&context, Digest);
} }

73
sha256.h
View File

@ -5,7 +5,8 @@
// Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org // Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org
// Modified by WaterJuice retaining Public Domain license. // Modified by WaterJuice retaining Public Domain license.
// //
// This is free and unencumbered software released into the public domain - June 2013 waterjuice.org // This is free and unencumbered software released into the public domain -
// June 2013 waterjuice.org
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#pragma once #pragma once
@ -17,19 +18,17 @@
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
typedef struct typedef struct {
{ uint64_t length;
uint64_t length; uint32_t state[8];
uint32_t state[8]; uint32_t curlen;
uint32_t curlen; uint8_t buf[64];
uint8_t buf[64];
} Sha256Context; } Sha256Context;
#define SHA256_HASH_SIZE ( 256 / 8 ) #define SHA256_HASH_SIZE (256 / 8)
typedef struct typedef struct {
{ uint8_t bytes[SHA256_HASH_SIZE];
uint8_t bytes [SHA256_HASH_SIZE];
} SHA256_HASH; } SHA256_HASH;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -41,49 +40,39 @@ typedef struct
// //
// Initialises a SHA256 Context. Use this to initialise/reset a context. // Initialises a SHA256 Context. Use this to initialise/reset a context.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Initialise(Sha256Context* Context // [out]
Sha256Initialise );
(
Sha256Context* Context // [out]
);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Update // Sha256Update
// //
// Adds data to the SHA256 context. This will process the data and update the internal state of the context. Keep on // Adds data to the SHA256 context. This will process the data and update the
// calling this function until all the data has been added. Then call Sha256Finalise to calculate the hash. // internal state of the context. Keep on calling this function until all the
// data has been added. Then call Sha256Finalise to calculate the hash.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Update(Sha256Context* Context, // [in out]
Sha256Update void const* Buffer, // [in]
( uint32_t BufferSize // [in]
Sha256Context* Context, // [in out] );
void const* Buffer, // [in]
uint32_t BufferSize // [in]
);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Finalise // Sha256Finalise
// //
// Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). After // Performs the final calculation of the hash and returns the digest (32 byte
// calling this, Sha256Initialised must be used to reuse the context. // buffer containing 256bit hash). After calling this, Sha256Initialised must
// be used to reuse the context.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Finalise(Sha256Context* Context, // [in out]
Sha256Finalise SHA256_HASH* Digest // [out]
( );
Sha256Context* Context, // [in out]
SHA256_HASH* Digest // [out]
);
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Sha256Calculate // Sha256Calculate
// //
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one function. Calculates the SHA256 hash of the // Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one
// buffer. // function. Calculates the SHA256 hash of the buffer.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void void Sha256Calculate(void const* Buffer, // [in]
Sha256Calculate uint32_t BufferSize, // [in]
( SHA256_HASH* Digest // [in]
void const* Buffer, // [in] );
uint32_t BufferSize, // [in]
SHA256_HASH* Digest // [in]
);