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

21
examples/simple_example.cpp
View File

@ -1,11 +1,11 @@
#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
@ -18,11 +18,8 @@ int main() {
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) {
@ -35,9 +32,7 @@ int main() {
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;
} }

110
examples/tests.cpp
View File

@ -10,13 +10,18 @@
#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,
const std::string& expected) {
std::stringstream ss; std::stringstream ss;
for (uint8_t i : result) { ss << std::hex << std::setfill('0') << std::setw(2) << (int)i; } for (uint8_t i : result) {
ss << std::hex << std::setfill('0') << std::setw(2) << (int)i;
}
if (expected != ss.str()) { if (expected != ss.str()) {
std::cout << "*** TEST FAILED ***: \n\t" << ss.str() << " != \n\t" << expected << std::endl; std::cout << "*** TEST FAILED ***: \n\t" << ss.str() << " != \n\t"
<< expected << std::endl;
} else { } else {
std::cout << "Test successful" << std::endl; std::cout << "Test successful" << std::endl;
} }
@ -24,15 +29,11 @@ static void verify_result(const std::vector<uint8_t>& result, const std::string&
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));
} }
@ -43,46 +44,85 @@ int main() {
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"
"\x0b\x0b\x0b",
"\x48\x69\x20\x54\x68\x65\x72\x65", "\x48\x69\x20\x54\x68\x65\x72\x65",
"b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7", "b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7",
}, { },
{
/* Test with a key shorter than the length of the HMAC output. */ /* Test with a key shorter than the length of the HMAC output. */
"\x4a\x65\x66\x65", "\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", "\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", "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843",
}, { },
{
/* Test with a combined length of key and data that is larger than 64 /* Test with a combined length of key and data that is larger than 64
bytes (= block-size of SHA-224 and SHA-256). */ 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", "\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", "\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", "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe",
}, { },
{
/* Test with a combined length of key and data that is larger than 64 /* Test with a combined length of key and data that is larger than 64
bytes (= block-size of SHA-224 and SHA-256). */ 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", "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11"
"\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", "\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", "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b",
}, { },
{
/* Test with a truncation of output to 128 bits. */ /* 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", "\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", "\x0c\x0c\x0c",
"\x54\x65\x73\x74\x20\x57\x69\x74\x68\x20\x54\x72\x75\x6e\x63\x61\x74"
"\x69\x6f\x6e",
"a3b6167473100ee06e0c796c2955552b", "a3b6167473100ee06e0c796c2955552b",
}, { },
{
/* Test with a key larger than 128 bytes (= block-size of SHA-384 and /* Test with a key larger than 128 bytes (= block-size of SHA-384 and
SHA-512). */ 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", "\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", "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\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", "60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54",
}, { },
/* Test with a key and data that is larger than 128 bytes (= block-size {
of SHA-384 and SHA-512). */ /* Test with a key and data that is larger than 128 bytes (=
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa", block-size of SHA-384 and SHA-512). */
"\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", "\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa\xaa"
"\xaa\xaa\xaa\xaa\xaa\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", "9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2",
} }};
};
do_tests(test_vectors); do_tests(test_vectors);
return 0; return 0;
} }

63
hmac_sha256.c
View File

@ -15,19 +15,25 @@
/* 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,
const size_t datalen,
void* out,
const size_t outlen) {
uint8_t k[SHA256_BLOCK_SIZE]; uint8_t k[SHA256_BLOCK_SIZE];
uint8_t k_ipad[SHA256_BLOCK_SIZE]; uint8_t k_ipad[SHA256_BLOCK_SIZE];
uint8_t k_opad[SHA256_BLOCK_SIZE]; uint8_t k_opad[SHA256_BLOCK_SIZE];
@ -55,35 +61,37 @@ size_t hmac_sha256(const void *key, const size_t keylen,
// 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,
void* out,
const size_t outlen) {
const size_t buflen = xlen + ylen; const size_t buflen = xlen + ylen;
uint8_t buf[buflen]; 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,
const size_t outlen) {
size_t sz; size_t sz;
Sha256Context ctx; Sha256Context ctx;
SHA256_HASH hash; SHA256_HASH hash;
@ -95,4 +103,3 @@ static void* sha256(const void *data, const size_t datalen,
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);
} }

11
hmac_sha256.h
View File

@ -16,20 +16,21 @@ 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_

137
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
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@ -24,20 +25,30 @@
#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,8 +68,7 @@ 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
@ -87,14 +97,7 @@ static const uint32_t K[64] = {
// //
// Compress 512-bits // Compress 512-bits
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static static void TransformFunction(Sha256Context* Context, uint8_t const* Buffer) {
void
TransformFunction
(
Sha256Context* Context,
uint8_t const* Buffer
)
{
uint32_t S[8]; uint32_t S[8];
uint32_t W[64]; uint32_t W[64];
uint32_t t0; uint32_t t0;
@ -103,26 +106,22 @@ void
int i; 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];
@ -136,8 +135,7 @@ void
} }
// 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,12 +149,8 @@ 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 ) {
(
Sha256Context* Context // [out]
)
{
Context->curlen = 0; Context->curlen = 0;
Context->length = 0; Context->length = 0;
Context->state[0] = 0x6A09E667UL; Context->state[0] = 0x6A09E667UL;
@ -172,42 +166,33 @@ void
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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
(
Sha256Context* Context, // [in out]
void const* Buffer, // [in] void const* Buffer, // [in]
uint32_t BufferSize // [in] uint32_t BufferSize // [in]
) ) {
{
uint32_t n; 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); TransformFunction(Context, (uint8_t*)Buffer);
Context->length += BLOCK_SIZE * 8; Context->length += BLOCK_SIZE * 8;
Buffer = (uint8_t*)Buffer + BLOCK_SIZE; Buffer = (uint8_t*)Buffer + BLOCK_SIZE;
BufferSize -= BLOCK_SIZE; BufferSize -= BLOCK_SIZE;
} } else {
else
{
n = MIN(BufferSize, (BLOCK_SIZE - Context->curlen)); n = MIN(BufferSize, (BLOCK_SIZE - Context->curlen));
memcpy(Context->buf + Context->curlen, Buffer, (size_t)n); memcpy(Context->buf + Context->curlen, Buffer, (size_t)n);
Context->curlen += n; Context->curlen += n;
Buffer = (uint8_t*)Buffer + n; Buffer = (uint8_t*)Buffer + n;
BufferSize -= n; BufferSize -= n;
if( Context->curlen == BLOCK_SIZE ) if (Context->curlen == BLOCK_SIZE) {
{
TransformFunction(Context, Context->buf); TransformFunction(Context, Context->buf);
Context->length += 8 * BLOCK_SIZE; Context->length += 8 * BLOCK_SIZE;
Context->curlen = 0; Context->curlen = 0;
@ -219,20 +204,16 @@ void
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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
(
Sha256Context* Context, // [in out]
SHA256_HASH* Digest // [out] SHA256_HASH* Digest // [out]
) ) {
{
int i; int i;
if( Context->curlen >= sizeof(Context->buf) ) if (Context->curlen >= sizeof(Context->buf)) {
{
return; return;
} }
@ -245,10 +226,8 @@ void
// if the length is currently above 56 bytes we append zeros // if the length is currently above 56 bytes we append zeros
// then compress. Then we can fall back to padding zeros and length // then compress. Then we can fall back to padding zeros and length
// encoding like normal. // encoding like normal.
if( Context->curlen > 56 ) if (Context->curlen > 56) {
{ while (Context->curlen < 64) {
while( Context->curlen < 64 )
{
Context->buf[Context->curlen++] = (uint8_t)0; Context->buf[Context->curlen++] = (uint8_t)0;
} }
TransformFunction(Context, Context->buf); TransformFunction(Context, Context->buf);
@ -256,8 +235,7 @@ void
} }
// Pad up to 56 bytes of zeroes // Pad up to 56 bytes of zeroes
while( Context->curlen < 56 ) while (Context->curlen < 56) {
{
Context->buf[Context->curlen++] = (uint8_t)0; Context->buf[Context->curlen++] = (uint8_t)0;
} }
@ -266,8 +244,7 @@ void
TransformFunction(Context, Context->buf); TransformFunction(Context, Context->buf);
// Copy output // Copy output
for( i=0; i<8; i++ ) for (i = 0; i < 8; i++) {
{
STORE32H(Context->state[i], Digest->bytes + (4 * i)); STORE32H(Context->state[i], Digest->bytes + (4 * i));
} }
} }
@ -275,17 +252,13 @@ void
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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
(
void const* Buffer, // [in]
uint32_t BufferSize, // [in] uint32_t BufferSize, // [in]
SHA256_HASH* Digest // [in] SHA256_HASH* Digest // [in]
) ) {
{
Sha256Context context; Sha256Context context;
Sha256Initialise(&context); Sha256Initialise(&context);

43
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,8 +18,7 @@
#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;
@ -27,8 +27,7 @@ typedef struct
#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,22 +40,17 @@ 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
(
Sha256Context* Context, // [in out]
void const* Buffer, // [in] void const* Buffer, // [in]
uint32_t BufferSize // [in] uint32_t BufferSize // [in]
); );
@ -64,26 +58,21 @@ void
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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
(
Sha256Context* Context, // [in out]
SHA256_HASH* Digest // [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
(
void const* Buffer, // [in]
uint32_t BufferSize, // [in] uint32_t BufferSize, // [in]
SHA256_HASH* Digest // [in] SHA256_HASH* Digest // [in]
); );