nerdcruft/libcruft-crypto
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

hash/sha1: style

Browse Source
This commit is contained in:
Danny Robson 2019-02-04 20:46:57 +11:00
parent 485cc52a7b
commit c4960e337e
1 changed files with 34 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
hash/sha1.cpp
View File

@ -24,15 +24,15 @@ using cruft::crypto::hash::SHA1;
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Constant words for sequence of rounds // Constant words for sequence of rounds
static constexpr uint32_t K_00 = 0x5A827999; static constexpr u32 K_00 = 0x5A827999;
static constexpr uint32_t K_20 = 0x6ED9EBA1; static constexpr u32 K_20 = 0x6ED9EBA1;
static constexpr uint32_t K_40 = 0x8F1BBCDC; static constexpr u32 K_40 = 0x8F1BBCDC;
static constexpr uint32_t K_60 = 0xCA62C1D6; static constexpr u32 K_60 = 0xCA62C1D6;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static constexpr static constexpr
std::array<uint32_t,5> INITIAL_H = { std::array<u32,5> INITIAL_H = {
0x67452301, 0x67452301,
0xEFCDAB89, 0xEFCDAB89,
0x98BADCFE, 0x98BADCFE,
@ -43,82 +43,53 @@ std::array<uint32_t,5> INITIAL_H = {
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
static constexpr size_t BLOCK_WORDS = 16; static constexpr size_t BLOCK_WORDS = 16;
static constexpr size_t BLOCK_BYTES = BLOCK_WORDS * sizeof (uint32_t); static constexpr size_t BLOCK_BYTES = BLOCK_WORDS * sizeof (u32);
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Logical function for sequence of rounds // Logical function for sequence of rounds
static constexpr static constexpr u32 f_00 (u32 B, u32 C, u32 D) { return (B & C) | (~B & D); }
uint32_t static constexpr u32 f_20 (u32 B, u32 C, u32 D) { return B ^ C ^ D; }
f_00 (uint32_t B, uint32_t C, uint32_t D) static constexpr u32 f_40 (u32 B, u32 C, u32 D) { return (B & C) | (B & D) | (C & D); }
{ static constexpr u32 f_60 (u32 B, u32 C, u32 D) { return B ^ C ^ D; }
return (B & C) | (~B & D);
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
f_20 (uint32_t B, uint32_t C, uint32_t D)
{
return B ^ C ^ D;
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
f_40 (uint32_t B, uint32_t C, uint32_t D)
{
return (B & C) | (B & D) | (C & D);
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
f_60 (uint32_t B, uint32_t C, uint32_t D)
{
return B ^ C ^ D;
}
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
static void static void
process (std::array<uint32_t,5> &H, std::array<uint32_t,16+64> &W) process (std::array<u32,5> &H, std::array<u32,16+64> &W)
{ {
// Byteswap the raw input we have buffered ready for arithmetic // Byteswap the raw input we have buffered ready for arithmetic
std::transform (std::begin (W), std::transform (std::begin (W),
std::end (W), std::end (W),
std::begin (W), std::begin (W),
[] (uint32_t x) { [] (u32 x) {
return cruft::ntoh (x); return cruft::ntoh (x);
}); });
// Initialise the work buffer and the state variables // Initialise the work buffer and the state variables
for (size_t t = 16; t < 80; ++t) for (int t = 16; t < 80; ++t)
W[t] = cruft::rotatel (W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1); W[t] = cruft::rotatel (W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
uint32_t A = H[0], u32 A = H[0],
B = H[1], B = H[1],
C = H[2], C = H[2],
D = H[3], D = H[3],
E = H[4]; E = H[4];
// Perform each of the four rounds // Perform each of the four rounds
#define ROTATE_STATE(i) do { \ #define ROTATE_STATE(i) do { \
uint32_t temp = cruft::rotatel (A, 5) + f_##i (B, C, D) + E + W[t] + K_##i; \ u32 temp = cruft::rotatel (A, 5) + f_##i (B, C, D) + E + W[t] + K_##i; \
E = D; \ E = D; \
D = C; \ D = C; \
C = cruft::rotatel (B, 30); \ C = cruft::rotatel (B, 30); \
B = A; \ B = A; \
A = temp; \ A = temp; \
} while (0) } while (0)
for (size_t t = 0; t < 20; ++t) ROTATE_STATE(00); for (int t = 0; t < 20; ++t) ROTATE_STATE(00);
for (size_t t = 20; t < 40; ++t) ROTATE_STATE(20); for (int t = 20; t < 40; ++t) ROTATE_STATE(20);
for (size_t t = 40; t < 60; ++t) ROTATE_STATE(40); for (int t = 40; t < 60; ++t) ROTATE_STATE(40);
for (size_t t = 60; t < 80; ++t) ROTATE_STATE(60); for (int t = 60; t < 80; ++t) ROTATE_STATE(60);
// Update the resulting hash state // Update the resulting hash state
H[0] += A; H[0] += A;
@ -131,7 +102,7 @@ process (std::array<uint32_t,5> &H, std::array<uint32_t,16+64> &W)
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
SHA1::digest_t SHA1::digest_t
SHA1::operator() (cruft::view<const uint8_t*> data) noexcept SHA1::operator() (cruft::view<const u08*> data) noexcept
{ {
return (*this) (data, nullptr); return (*this) (data, nullptr);
} }
@ -140,20 +111,20 @@ SHA1::operator() (cruft::view<const uint8_t*> data) noexcept
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
SHA1::digest_t SHA1::digest_t
SHA1::operator() ( SHA1::operator() (
cruft::view<const uint8_t*> data_a, cruft::view<const u08*> data_a,
cruft::view<const uint8_t*> data_b cruft::view<const u08*> data_b
) noexcept { ) noexcept {
/* RESET */ /* RESET */
uint64_t total = 0; u64 total = 0;
union { union {
std::array<uint32_t,5> w; std::array<u32,5> w;
std::array<uint8_t,20> b; std::array<u08,20> b;
} H; } H;
union { union {
std::array<uint8_t, 16*4+64*4> c; std::array<u08, 16*4+64*4> c;
std::array<uint32_t, 16 +64 > W; std::array<u32, 16 +64 > W;
} state; } state;
H.w = INITIAL_H; H.w = INITIAL_H;
@ -204,6 +175,6 @@ SHA1::operator() (
} }
/* DIGEST */ /* DIGEST */
std::transform (std::begin (H.w), std::end (H.w), std::begin (H.w), cruft::hton<uint32_t>); std::transform (std::begin (H.w), std::end (H.w), std::begin (H.w), cruft::hton<u32>);
return H.b; return H.b;
} }