Format code using clang-format
Use malloc instead of VLAs (C99). Fixes #3
This commit is contained in:
h5p9sl
parent
197a2b309a
commit
4189b1de64
|
|
@ -0,0 +1,2 @@
|
|||
BasedOnStyle: Chromium
|
||||
Standard: Cpp11
|
||||
|
|
@ -1,43 +1,38 @@
|
|||
#include "../hmac_sha256.h"
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
#include <iomanip>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <iomanip>
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#define SHA256_HASH_SIZE 32
|
||||
|
||||
int main() {
|
||||
const std::string str_data = "Hello World!";
|
||||
const std::string str_key = "super-secret-key";
|
||||
std::stringstream ss_result;
|
||||
const std::string str_data = "Hello World!";
|
||||
const std::string str_key = "super-secret-key";
|
||||
std::stringstream ss_result;
|
||||
|
||||
// Allocate memory for the HMAC
|
||||
std::vector<uint8_t> out(SHA256_HASH_SIZE);
|
||||
// Allocate memory for the HMAC
|
||||
std::vector<uint8_t> out(SHA256_HASH_SIZE);
|
||||
|
||||
// Call hmac-sha256 function
|
||||
hmac_sha256(
|
||||
str_key.data(), str_key.size(),
|
||||
str_data.data(), str_data.size(),
|
||||
out.data(), out.size()
|
||||
);
|
||||
// Call hmac-sha256 function
|
||||
hmac_sha256(str_key.data(), str_key.size(), str_data.data(), str_data.size(),
|
||||
out.data(), out.size());
|
||||
|
||||
// Convert `out` to string with std::hex
|
||||
for (uint8_t x : out) {
|
||||
ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;
|
||||
}
|
||||
// Convert `out` to string with std::hex
|
||||
for (uint8_t x : out) {
|
||||
ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;
|
||||
}
|
||||
|
||||
// Print out the result
|
||||
std::cout << "Message: " << str_data << std::endl;
|
||||
std::cout << "Key: " << str_key << std::endl;
|
||||
std::cout << "HMAC: " << ss_result.str() << std::endl;
|
||||
// Print out the result
|
||||
std::cout << "Message: " << str_data << std::endl;
|
||||
std::cout << "Key: " << str_key << std::endl;
|
||||
std::cout << "HMAC: " << ss_result.str() << std::endl;
|
||||
|
||||
// This assertion fails if something went wrong
|
||||
assert(
|
||||
ss_result.str() ==
|
||||
"4b393abced1c497f8048860ba1ede46a23f1ff5209b18e9c428bddfbb690aad8"
|
||||
);
|
||||
return 0;
|
||||
// This assertion fails if something went wrong
|
||||
assert(ss_result.str() ==
|
||||
"4b393abced1c497f8048860ba1ede46a23f1ff5209b18e9c428bddfbb690aad8");
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,79 +10,119 @@
|
|||
|
||||
#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) {
|
||||
std::stringstream ss;
|
||||
for (uint8_t i : result) { ss << std::hex << std::setfill('0') << std::setw(2) << (int)i; }
|
||||
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 verify_result(const std::vector<uint8_t>& result,
|
||||
const std::string& expected) {
|
||||
std::stringstream ss;
|
||||
for (uint8_t i : result) {
|
||||
ss << std::hex << std::setfill('0') << std::setw(2) << (int)i;
|
||||
}
|
||||
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) {
|
||||
for (auto tvec : test_vectors) {
|
||||
std::vector<uint8_t> out(
|
||||
std::get<2>(tvec).size() / 2
|
||||
);
|
||||
for (auto tvec : test_vectors) {
|
||||
std::vector<uint8_t> out(std::get<2>(tvec).size() / 2);
|
||||
|
||||
hmac_sha256(
|
||||
std::get<0>(tvec).data(), std::get<0>(tvec).size(),
|
||||
std::get<1>(tvec).data(), std::get<1>(tvec).size(),
|
||||
out.data(), out.size()
|
||||
);
|
||||
hmac_sha256(std::get<0>(tvec).data(), std::get<0>(tvec).size(),
|
||||
std::get<1>(tvec).data(), std::get<1>(tvec).size(), out.data(),
|
||||
out.size());
|
||||
|
||||
verify_result(out, std::get<2>(tvec));
|
||||
}
|
||||
verify_result(out, std::get<2>(tvec));
|
||||
}
|
||||
}
|
||||
|
||||
int main() {
|
||||
// Test vectors from RFC4231, https://tools.ietf.org/html/rfc4231#section-4
|
||||
const TestData_t test_vectors = {
|
||||
// Key Data HMAC
|
||||
{
|
||||
"\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",
|
||||
"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",
|
||||
"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
|
||||
}, {
|
||||
/* Test with a combined length of key and data that is larger than 64
|
||||
bytes (= block-size of SHA-224 and SHA-256). */
|
||||
"\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). */
|
||||
"\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",
|
||||
"\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",
|
||||
"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
|
||||
}, {
|
||||
/* 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",
|
||||
"a3b6167473100ee06e0c796c2955552b",
|
||||
}, {
|
||||
/* 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;
|
||||
// Test vectors from RFC4231, https://tools.ietf.org/html/rfc4231#section-4
|
||||
const TestData_t test_vectors = {
|
||||
// Key Data HMAC
|
||||
{
|
||||
"\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",
|
||||
"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",
|
||||
"5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
|
||||
},
|
||||
{
|
||||
/* Test with a combined length of key and data that is larger than 64
|
||||
bytes (= block-size of SHA-224 and SHA-256). */
|
||||
"\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). */
|
||||
"\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",
|
||||
"\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",
|
||||
"82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
|
||||
},
|
||||
{
|
||||
/* 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",
|
||||
"a3b6167473100ee06e0c796c2955552b",
|
||||
},
|
||||
{
|
||||
/* 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
137
hmac_sha256.c
|
|
@ -15,84 +15,91 @@
|
|||
/* LOCAL FUNCTIONS */
|
||||
|
||||
// Concatenate X & Y, return hash.
|
||||
static void* H(const void *x, const size_t xlen,
|
||||
const void *y, const size_t ylen,
|
||||
void *out, const size_t outlen
|
||||
);
|
||||
static void* H(const void* x,
|
||||
const size_t xlen,
|
||||
const void* y,
|
||||
const size_t ylen,
|
||||
void* out,
|
||||
const size_t outlen);
|
||||
// Wrapper for sha256
|
||||
static void* sha256(const void *data, const size_t datalen,
|
||||
void *out, const size_t outlen
|
||||
);
|
||||
static void* sha256(const void* data,
|
||||
const size_t datalen,
|
||||
void* out,
|
||||
const size_t outlen);
|
||||
|
||||
// Declared in hmac_sha256.h
|
||||
size_t hmac_sha256(const void *key, const size_t keylen,
|
||||
const void *data, const size_t datalen,
|
||||
void *out, const size_t outlen) {
|
||||
uint8_t k[SHA256_BLOCK_SIZE];
|
||||
uint8_t k_ipad[SHA256_BLOCK_SIZE];
|
||||
uint8_t k_opad[SHA256_BLOCK_SIZE];
|
||||
uint8_t ihash[SHA256_HASH_SIZE];
|
||||
uint8_t ohash[SHA256_HASH_SIZE];
|
||||
size_t sz;
|
||||
int i;
|
||||
size_t hmac_sha256(const void* key,
|
||||
const size_t keylen,
|
||||
const void* data,
|
||||
const size_t datalen,
|
||||
void* out,
|
||||
const size_t outlen) {
|
||||
uint8_t k[SHA256_BLOCK_SIZE];
|
||||
uint8_t k_ipad[SHA256_BLOCK_SIZE];
|
||||
uint8_t k_opad[SHA256_BLOCK_SIZE];
|
||||
uint8_t ihash[SHA256_HASH_SIZE];
|
||||
uint8_t ohash[SHA256_HASH_SIZE];
|
||||
size_t sz;
|
||||
int i;
|
||||
|
||||
memset(k, 0, SIZEOFARRAY(k));
|
||||
memset(k_ipad, 0x36, SHA256_BLOCK_SIZE);
|
||||
memset(k_opad, 0x5c, SHA256_BLOCK_SIZE);
|
||||
memset(k, 0, SIZEOFARRAY(k));
|
||||
memset(k_ipad, 0x36, SHA256_BLOCK_SIZE);
|
||||
memset(k_opad, 0x5c, SHA256_BLOCK_SIZE);
|
||||
|
||||
if (keylen > SHA256_BLOCK_SIZE) {
|
||||
// If the key is larger than the hash algorithm's
|
||||
// block size, we must digest it first.
|
||||
sha256(key, keylen, k, SIZEOFARRAY(k));
|
||||
} else {
|
||||
memcpy(k, key, keylen);
|
||||
}
|
||||
if (keylen > SHA256_BLOCK_SIZE) {
|
||||
// If the key is larger than the hash algorithm's
|
||||
// block size, we must digest it first.
|
||||
sha256(key, keylen, k, SIZEOFARRAY(k));
|
||||
} else {
|
||||
memcpy(k, key, keylen);
|
||||
}
|
||||
|
||||
for (i = 0; i < SHA256_BLOCK_SIZE; i++) {
|
||||
k_ipad[i] ^= k[i];
|
||||
k_opad[i] ^= k[i];
|
||||
}
|
||||
for (i = 0; i < SHA256_BLOCK_SIZE; i++) {
|
||||
k_ipad[i] ^= k[i];
|
||||
k_opad[i] ^= k[i];
|
||||
}
|
||||
|
||||
// Perform HMAC algorithm: ( https://tools.ietf.org/html/rfc2104 )
|
||||
// `H(K XOR opad, H(K XOR ipad, data))`
|
||||
H(k_ipad, SIZEOFARRAY(k_ipad),
|
||||
data, datalen,
|
||||
ihash, SIZEOFARRAY(ihash)
|
||||
);
|
||||
H(k_opad, SIZEOFARRAY(k_opad),
|
||||
ihash, SIZEOFARRAY(ihash),
|
||||
ohash, SIZEOFARRAY(ohash)
|
||||
);
|
||||
// Perform HMAC algorithm: ( https://tools.ietf.org/html/rfc2104 )
|
||||
// `H(K XOR opad, H(K XOR ipad, data))`
|
||||
H(k_ipad, SIZEOFARRAY(k_ipad), data, datalen, ihash, SIZEOFARRAY(ihash));
|
||||
H(k_opad, SIZEOFARRAY(k_opad), ihash, SIZEOFARRAY(ihash), ohash,
|
||||
SIZEOFARRAY(ohash));
|
||||
|
||||
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
|
||||
memcpy(out, ohash, sz);
|
||||
return sz;
|
||||
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
|
||||
memcpy(out, ohash, sz);
|
||||
return sz;
|
||||
}
|
||||
|
||||
static void* H(const void *x, const size_t xlen,
|
||||
const void *y, const size_t ylen,
|
||||
void *out, const size_t outlen
|
||||
) {
|
||||
const size_t buflen = xlen + ylen;
|
||||
uint8_t buf[buflen];
|
||||
static void* H(const void* x,
|
||||
const size_t xlen,
|
||||
const void* y,
|
||||
const size_t ylen,
|
||||
void* out,
|
||||
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 + xlen, y, ylen);
|
||||
return sha256(buf, buflen * sizeof(uint8_t), out, outlen);
|
||||
memcpy(buf, x, xlen);
|
||||
memcpy(buf + xlen, y, ylen);
|
||||
result = sha256(buf, buflen, out, outlen);
|
||||
|
||||
free(buf);
|
||||
return result;
|
||||
}
|
||||
|
||||
static void* sha256(const void *data, const size_t datalen,
|
||||
void *out, const size_t outlen
|
||||
) {
|
||||
size_t sz;
|
||||
Sha256Context ctx;
|
||||
SHA256_HASH hash;
|
||||
static void* sha256(const void* data,
|
||||
const size_t datalen,
|
||||
void* out,
|
||||
const size_t outlen) {
|
||||
size_t sz;
|
||||
Sha256Context ctx;
|
||||
SHA256_HASH hash;
|
||||
|
||||
Sha256Initialise(&ctx);
|
||||
Sha256Update(&ctx, data, datalen);
|
||||
Sha256Finalise(&ctx, &hash);
|
||||
Sha256Initialise(&ctx);
|
||||
Sha256Update(&ctx, data, datalen);
|
||||
Sha256Finalise(&ctx, &hash);
|
||||
|
||||
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
|
||||
return memcpy(out, hash.bytes, sz);
|
||||
sz = (outlen > SHA256_HASH_SIZE) ? SHA256_HASH_SIZE : outlen;
|
||||
return memcpy(out, hash.bytes, sz);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -8,28 +8,29 @@
|
|||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif // __cplusplus
|
||||
#endif // __cplusplus
|
||||
|
||||
#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(
|
||||
// [in]: The key and its length.
|
||||
// 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.
|
||||
const void* data, const size_t datalen,
|
||||
const void* data,
|
||||
const size_t datalen,
|
||||
|
||||
// [out]: The output hash.
|
||||
// Should be 32 bytes long. If it's less than 32 bytes,
|
||||
// the resulting hash will be truncated to the specified length.
|
||||
void* out, const size_t outlen
|
||||
);
|
||||
void* out,
|
||||
const size_t outlen);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // _HMAC_SHA256_H_
|
||||
#endif // __cplusplus
|
||||
|
||||
#endif // _HMAC_SHA256_H_
|
||||
|
|
|
|||
357
sha256.c
357
sha256.c
|
|
@ -5,7 +5,8 @@
|
|||
// Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org
|
||||
// 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 MIN(x, y) ( ((x)<(y))?(x):(y) )
|
||||
#define MIN(x, y) (((x) < (y)) ? (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); }
|
||||
#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); \
|
||||
}
|
||||
|
||||
#define LOAD32H(x, y) \
|
||||
{ x = ((uint32_t)((y)[0] & 255)<<24) | \
|
||||
((uint32_t)((y)[1] & 255)<<16) | \
|
||||
((uint32_t)((y)[2] & 255)<<8) | \
|
||||
((uint32_t)((y)[3] & 255)); }
|
||||
#define LOAD32H(x, y) \
|
||||
{ \
|
||||
x = ((uint32_t)((y)[0] & 255) << 24) | ((uint32_t)((y)[1] & 255) << 16) | \
|
||||
((uint32_t)((y)[2] & 255) << 8) | ((uint32_t)((y)[3] & 255)); \
|
||||
}
|
||||
|
||||
#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)[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); }
|
||||
#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)[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
|
||||
|
|
@ -57,89 +68,76 @@ static const uint32_t K[64] = {
|
|||
0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, 0x19a4c116UL, 0x1e376c08UL,
|
||||
0x2748774cUL, 0x34b0bcb5UL, 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL,
|
||||
0x682e6ff3UL, 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
|
||||
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
|
||||
};
|
||||
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL};
|
||||
|
||||
#define BLOCK_SIZE 64
|
||||
#define BLOCK_SIZE 64
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// INTERNAL FUNCTIONS
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Various logical functions
|
||||
#define Ch( x, y, z ) (z ^ (x & (y ^ z)))
|
||||
#define Maj( x, y, z ) (((x | y) & z) | (x & y))
|
||||
#define S( x, n ) ror((x),(n))
|
||||
#define R( x, n ) (((x)&0xFFFFFFFFUL)>>(n))
|
||||
#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 Gamma0( x ) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
|
||||
#define Gamma1( x ) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
|
||||
#define Ch(x, y, z) (z ^ (x & (y ^ z)))
|
||||
#define Maj(x, y, z) (((x | y) & z) | (x & y))
|
||||
#define S(x, n) ror((x), (n))
|
||||
#define R(x, n) (((x)&0xFFFFFFFFUL) >> (n))
|
||||
#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 Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
|
||||
#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
|
||||
|
||||
#define Sha256Round( a, b, c, d, e, f, g, h, i ) \
|
||||
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
|
||||
t1 = Sigma0(a) + Maj(a, b, c); \
|
||||
d += t0; \
|
||||
h = t0 + t1;
|
||||
#define Sha256Round(a, b, c, d, e, f, g, h, i) \
|
||||
t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
|
||||
t1 = Sigma0(a) + Maj(a, b, c); \
|
||||
d += t0; \
|
||||
h = t0 + t1;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// TransformFunction
|
||||
//
|
||||
// Compress 512-bits
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
static
|
||||
void
|
||||
TransformFunction
|
||||
(
|
||||
Sha256Context* Context,
|
||||
uint8_t const* Buffer
|
||||
)
|
||||
{
|
||||
uint32_t S[8];
|
||||
uint32_t W[64];
|
||||
uint32_t t0;
|
||||
uint32_t t1;
|
||||
uint32_t t;
|
||||
int i;
|
||||
static void TransformFunction(Sha256Context* Context, uint8_t const* Buffer) {
|
||||
uint32_t S[8];
|
||||
uint32_t W[64];
|
||||
uint32_t t0;
|
||||
uint32_t t1;
|
||||
uint32_t t;
|
||||
int i;
|
||||
|
||||
// Copy state into S
|
||||
for( i=0; i<8; i++ )
|
||||
{
|
||||
S[i] = Context->state[i];
|
||||
}
|
||||
// Copy state into S
|
||||
for (i = 0; i < 8; i++) {
|
||||
S[i] = Context->state[i];
|
||||
}
|
||||
|
||||
// Copy the state into 512-bits into W[0..15]
|
||||
for( i=0; i<16; i++ )
|
||||
{
|
||||
LOAD32H( W[i], Buffer + (4*i) );
|
||||
}
|
||||
// Copy the state into 512-bits into W[0..15]
|
||||
for (i = 0; i < 16; i++) {
|
||||
LOAD32H(W[i], Buffer + (4 * i));
|
||||
}
|
||||
|
||||
// Fill W[16..63]
|
||||
for( i=16; i<64; i++ )
|
||||
{
|
||||
W[i] = Gamma1( W[i-2]) + W[i-7] + Gamma0( W[i-15] ) + W[i-16];
|
||||
}
|
||||
// Fill W[16..63]
|
||||
for (i = 16; i < 64; i++) {
|
||||
W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
|
||||
}
|
||||
|
||||
// Compress
|
||||
for( i=0; i<64; i++ )
|
||||
{
|
||||
Sha256Round( S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i );
|
||||
t = S[7];
|
||||
S[7] = S[6];
|
||||
S[6] = S[5];
|
||||
S[5] = S[4];
|
||||
S[4] = S[3];
|
||||
S[3] = S[2];
|
||||
S[2] = S[1];
|
||||
S[1] = S[0];
|
||||
S[0] = t;
|
||||
}
|
||||
// Compress
|
||||
for (i = 0; i < 64; i++) {
|
||||
Sha256Round(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
|
||||
t = S[7];
|
||||
S[7] = S[6];
|
||||
S[6] = S[5];
|
||||
S[5] = S[4];
|
||||
S[4] = S[3];
|
||||
S[3] = S[2];
|
||||
S[2] = S[1];
|
||||
S[1] = S[0];
|
||||
S[0] = t;
|
||||
}
|
||||
|
||||
// Feedback
|
||||
for( i=0; i<8; i++ )
|
||||
{
|
||||
Context->state[i] = Context->state[i] + S[i];
|
||||
}
|
||||
// Feedback
|
||||
for (i = 0; i < 8; 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.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Initialise
|
||||
(
|
||||
Sha256Context* Context // [out]
|
||||
)
|
||||
{
|
||||
Context->curlen = 0;
|
||||
Context->length = 0;
|
||||
Context->state[0] = 0x6A09E667UL;
|
||||
Context->state[1] = 0xBB67AE85UL;
|
||||
Context->state[2] = 0x3C6EF372UL;
|
||||
Context->state[3] = 0xA54FF53AUL;
|
||||
Context->state[4] = 0x510E527FUL;
|
||||
Context->state[5] = 0x9B05688CUL;
|
||||
Context->state[6] = 0x1F83D9ABUL;
|
||||
Context->state[7] = 0x5BE0CD19UL;
|
||||
void Sha256Initialise(Sha256Context* Context // [out]
|
||||
) {
|
||||
Context->curlen = 0;
|
||||
Context->length = 0;
|
||||
Context->state[0] = 0x6A09E667UL;
|
||||
Context->state[1] = 0xBB67AE85UL;
|
||||
Context->state[2] = 0x3C6EF372UL;
|
||||
Context->state[3] = 0xA54FF53AUL;
|
||||
Context->state[4] = 0x510E527FUL;
|
||||
Context->state[5] = 0x9B05688CUL;
|
||||
Context->state[6] = 0x1F83D9ABUL;
|
||||
Context->state[7] = 0x5BE0CD19UL;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Update
|
||||
//
|
||||
// Adds data to the SHA256 context. This will process the data and update the internal state of the context. Keep on
|
||||
// calling this function until all the data has been added. Then call Sha256Finalise to calculate the hash.
|
||||
// Adds data to the SHA256 context. This will process the data and update the
|
||||
// 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
|
||||
Sha256Update
|
||||
(
|
||||
Sha256Context* Context, // [in out]
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize // [in]
|
||||
)
|
||||
{
|
||||
uint32_t n;
|
||||
void Sha256Update(Sha256Context* Context, // [in out]
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize // [in]
|
||||
) {
|
||||
uint32_t n;
|
||||
|
||||
if( Context->curlen > sizeof(Context->buf) )
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (Context->curlen > sizeof(Context->buf)) {
|
||||
return;
|
||||
}
|
||||
|
||||
while( BufferSize > 0 )
|
||||
{
|
||||
if( Context->curlen == 0 && BufferSize >= BLOCK_SIZE )
|
||||
{
|
||||
TransformFunction( Context, (uint8_t*)Buffer );
|
||||
Context->length += BLOCK_SIZE * 8;
|
||||
Buffer = (uint8_t*)Buffer + BLOCK_SIZE;
|
||||
BufferSize -= BLOCK_SIZE;
|
||||
}
|
||||
else
|
||||
{
|
||||
n = MIN( BufferSize, (BLOCK_SIZE - Context->curlen) );
|
||||
memcpy( Context->buf + Context->curlen, Buffer, (size_t)n );
|
||||
Context->curlen += n;
|
||||
Buffer = (uint8_t*)Buffer + n;
|
||||
BufferSize -= n;
|
||||
if( Context->curlen == BLOCK_SIZE )
|
||||
{
|
||||
TransformFunction( Context, Context->buf );
|
||||
Context->length += 8*BLOCK_SIZE;
|
||||
Context->curlen = 0;
|
||||
}
|
||||
}
|
||||
while (BufferSize > 0) {
|
||||
if (Context->curlen == 0 && BufferSize >= BLOCK_SIZE) {
|
||||
TransformFunction(Context, (uint8_t*)Buffer);
|
||||
Context->length += BLOCK_SIZE * 8;
|
||||
Buffer = (uint8_t*)Buffer + BLOCK_SIZE;
|
||||
BufferSize -= BLOCK_SIZE;
|
||||
} else {
|
||||
n = MIN(BufferSize, (BLOCK_SIZE - Context->curlen));
|
||||
memcpy(Context->buf + Context->curlen, Buffer, (size_t)n);
|
||||
Context->curlen += n;
|
||||
Buffer = (uint8_t*)Buffer + n;
|
||||
BufferSize -= n;
|
||||
if (Context->curlen == BLOCK_SIZE) {
|
||||
TransformFunction(Context, Context->buf);
|
||||
Context->length += 8 * BLOCK_SIZE;
|
||||
Context->curlen = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Finalise
|
||||
//
|
||||
// Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). After
|
||||
// calling this, Sha256Initialised must be used to reuse the context.
|
||||
// Performs the final calculation of the hash and returns the digest (32 byte
|
||||
// buffer containing 256bit hash). After calling this, Sha256Initialised must
|
||||
// be used to reuse the context.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Finalise
|
||||
(
|
||||
Sha256Context* Context, // [in out]
|
||||
SHA256_HASH* Digest // [out]
|
||||
)
|
||||
{
|
||||
int i;
|
||||
void Sha256Finalise(Sha256Context* Context, // [in out]
|
||||
SHA256_HASH* Digest // [out]
|
||||
) {
|
||||
int i;
|
||||
|
||||
if( Context->curlen >= sizeof(Context->buf) )
|
||||
{
|
||||
return;
|
||||
if (Context->curlen >= sizeof(Context->buf)) {
|
||||
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
|
||||
Context->length += Context->curlen * 8;
|
||||
// Pad up to 56 bytes of zeroes
|
||||
while (Context->curlen < 56) {
|
||||
Context->buf[Context->curlen++] = (uint8_t)0;
|
||||
}
|
||||
|
||||
// Append the '1' bit
|
||||
Context->buf[Context->curlen++] = (uint8_t)0x80;
|
||||
// Store length
|
||||
STORE64H(Context->length, Context->buf + 56);
|
||||
TransformFunction(Context, Context->buf);
|
||||
|
||||
// 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;
|
||||
}
|
||||
|
||||
// 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) );
|
||||
}
|
||||
// Copy output
|
||||
for (i = 0; i < 8; i++) {
|
||||
STORE32H(Context->state[i], Digest->bytes + (4 * i));
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Calculate
|
||||
//
|
||||
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one function. Calculates the SHA256 hash of the
|
||||
// buffer.
|
||||
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one
|
||||
// function. Calculates the SHA256 hash of the buffer.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Calculate
|
||||
(
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize, // [in]
|
||||
SHA256_HASH* Digest // [in]
|
||||
)
|
||||
{
|
||||
Sha256Context context;
|
||||
void Sha256Calculate(void const* Buffer, // [in]
|
||||
uint32_t BufferSize, // [in]
|
||||
SHA256_HASH* Digest // [in]
|
||||
) {
|
||||
Sha256Context context;
|
||||
|
||||
Sha256Initialise( &context );
|
||||
Sha256Update( &context, Buffer, BufferSize );
|
||||
Sha256Finalise( &context, Digest );
|
||||
Sha256Initialise(&context);
|
||||
Sha256Update(&context, Buffer, BufferSize);
|
||||
Sha256Finalise(&context, Digest);
|
||||
}
|
||||
|
|
|
|||
73
sha256.h
73
sha256.h
|
|
@ -5,7 +5,8 @@
|
|||
// Original author: Tom St Denis, tomstdenis@gmail.com, http://libtom.org
|
||||
// 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
|
||||
|
|
@ -17,19 +18,17 @@
|
|||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint64_t length;
|
||||
uint32_t state[8];
|
||||
uint32_t curlen;
|
||||
uint8_t buf[64];
|
||||
typedef struct {
|
||||
uint64_t length;
|
||||
uint32_t state[8];
|
||||
uint32_t curlen;
|
||||
uint8_t buf[64];
|
||||
} Sha256Context;
|
||||
|
||||
#define SHA256_HASH_SIZE ( 256 / 8 )
|
||||
#define SHA256_HASH_SIZE (256 / 8)
|
||||
|
||||
typedef struct
|
||||
{
|
||||
uint8_t bytes [SHA256_HASH_SIZE];
|
||||
typedef struct {
|
||||
uint8_t bytes[SHA256_HASH_SIZE];
|
||||
} SHA256_HASH;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -41,49 +40,39 @@ typedef struct
|
|||
//
|
||||
// Initialises a SHA256 Context. Use this to initialise/reset a context.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Initialise
|
||||
(
|
||||
Sha256Context* Context // [out]
|
||||
);
|
||||
void Sha256Initialise(Sha256Context* Context // [out]
|
||||
);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Update
|
||||
//
|
||||
// Adds data to the SHA256 context. This will process the data and update the internal state of the context. Keep on
|
||||
// calling this function until all the data has been added. Then call Sha256Finalise to calculate the hash.
|
||||
// Adds data to the SHA256 context. This will process the data and update the
|
||||
// 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
|
||||
Sha256Update
|
||||
(
|
||||
Sha256Context* Context, // [in out]
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize // [in]
|
||||
);
|
||||
void Sha256Update(Sha256Context* Context, // [in out]
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize // [in]
|
||||
);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Finalise
|
||||
//
|
||||
// Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). After
|
||||
// calling this, Sha256Initialised must be used to reuse the context.
|
||||
// Performs the final calculation of the hash and returns the digest (32 byte
|
||||
// buffer containing 256bit hash). After calling this, Sha256Initialised must
|
||||
// be used to reuse the context.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Finalise
|
||||
(
|
||||
Sha256Context* Context, // [in out]
|
||||
SHA256_HASH* Digest // [out]
|
||||
);
|
||||
void Sha256Finalise(Sha256Context* Context, // [in out]
|
||||
SHA256_HASH* Digest // [out]
|
||||
);
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Sha256Calculate
|
||||
//
|
||||
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one function. Calculates the SHA256 hash of the
|
||||
// buffer.
|
||||
// Combines Sha256Initialise, Sha256Update, and Sha256Finalise into one
|
||||
// function. Calculates the SHA256 hash of the buffer.
|
||||
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
void
|
||||
Sha256Calculate
|
||||
(
|
||||
void const* Buffer, // [in]
|
||||
uint32_t BufferSize, // [in]
|
||||
SHA256_HASH* Digest // [in]
|
||||
);
|
||||
void Sha256Calculate(void const* Buffer, // [in]
|
||||
uint32_t BufferSize, // [in]
|
||||
SHA256_HASH* Digest // [in]
|
||||
);
|
||||
|
|
|
|||
Loading…
Reference in New Issue