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

hash/md5: prefer std types

Browse Source
This commit is contained in:
Danny Robson 2019-02-09 15:20:13 +11:00
parent e213be2415
commit 103ede647b
1 changed files with 27 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
hash/md5.cpp
View File

@ -3,11 +3,12 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* Copyright 2013 Danny Robson <danny@nerdcruft.net>
* Copyright 2013-2019 Danny Robson <danny@nerdcruft.net>
*/
#include "md5.hpp"
#include <cruft/util/std.hpp>
#include <cruft/util/iterator.hpp>
#include <cruft/util/bitwise.hpp>
#include <cruft/util/debug.hpp>
@ -19,45 +20,16 @@ using cruft::crypto::hash::MD5;
///////////////////////////////////////////////////////////////////////////////
// Per-round mixing functions
static constexpr
uint32_t
F (uint32_t x, uint32_t y, uint32_t z)
{
return z ^ (x & (y ^ z));
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
G (uint32_t x, uint32_t y, uint32_t z)
{
return F (z, x, y);
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
H (uint32_t x, uint32_t y, uint32_t z)
{
return x ^ y ^ z;
}
//-----------------------------------------------------------------------------
static constexpr
uint32_t
I (uint32_t x, uint32_t y, uint32_t z)
{
return y ^ (x | ~z);
}
static constexpr u32 F (u32 x, u32 y, u32 z) { return z ^ (x & (y ^ z)); }
static constexpr u32 G (u32 x, u32 y, u32 z) { return F (z, x, y); }
static constexpr u32 H (u32 x, u32 y, u32 z) { return x ^ y ^ z; }
static constexpr u32 I (u32 x, u32 y, u32 z) { return y ^ (x | ~z); }
///////////////////////////////////////////////////////////////////////////////
// Mixing constants for all rounds. They are defined as 'abs(sin(i)) * max_uint32', but we use the
// Mixing constants for all rounds. They are defined as 'abs(sin(i)) * max_u32', but we use the
// literals to avoid any stupid maths issues during compilation.
const std::array<uint32_t, 65> T = { {
const std::array<u32, 65> T = { {
0x00000000,
// Round 1
@ -87,15 +59,15 @@ const std::array<uint32_t, 65> T = { {
//-----------------------------------------------------------------------------
static constexpr uint32_t INITIAL_A = 0x67452301;
static constexpr uint32_t INITIAL_B = 0xefcdab89;
static constexpr uint32_t INITIAL_C = 0x98badcfe;
static constexpr uint32_t INITIAL_D = 0x10325476;
static constexpr u32 INITIAL_A = 0x67452301;
static constexpr u32 INITIAL_B = 0xefcdab89;
static constexpr u32 INITIAL_C = 0x98badcfe;
static constexpr u32 INITIAL_D = 0x10325476;
///////////////////////////////////////////////////////////////////////////////
typename MD5::digest_t
MD5::operator() (cruft::view<const uint8_t*> a) const noexcept
MD5::operator() (cruft::view<const u08*> a) const noexcept
{
return (*this)(a, nullptr);
}
@ -103,7 +75,7 @@ MD5::operator() (cruft::view<const uint8_t*> a) const noexcept
//-----------------------------------------------------------------------------
typename MD5::digest_t
MD5::operator() (cruft::view<const uint8_t*> a, cruft::view<const uint8_t*> b) const noexcept
MD5::operator() (cruft::view<const u08*> a, cruft::view<const u08*> b) const noexcept
{
return (*this)(a, b, nullptr);
}
@ -112,13 +84,13 @@ MD5::operator() (cruft::view<const uint8_t*> a, cruft::view<const uint8_t*> b) c
///////////////////////////////////////////////////////////////////////////////
typename MD5::digest_t
MD5::operator() (
const cruft::view<const uint8_t*> data_a,
const cruft::view<const uint8_t*> data_b,
const cruft::view<const uint8_t*> data_c
const cruft::view<const u08*> data_a,
const cruft::view<const u08*> data_b,
const cruft::view<const u08*> data_c
) const noexcept {
union {
std::array<uint32_t,16> w;
std::array<uint8_t, 64> b;
std::array<u32,16> w;
std::array<u08, 64> b;
} X;
static_assert (sizeof (X.w) == BLOCK_SIZE);
@ -127,8 +99,8 @@ MD5::operator() (
static_assert (sizeof (X.b) == BLOCK_SIZE);
static_assert (X.b.size () == BLOCK_SIZE);
uint64_t m_total = 0;
std::array<uint32_t,4> ABCD = {
u64 m_total = 0;
std::array<u32,4> ABCD = {
INITIAL_A,
INITIAL_B,
INITIAL_C,
@ -144,7 +116,7 @@ MD5::operator() (
);
m_total = data_a.size () + data_b.size () + data_c.size ();
uint64_t bits = m_total * 8;
u64 bits = m_total * 8;
// Pad with the mandatory 1 bit
X.b[m_total % BLOCK_SIZE] = 0x80;
@ -180,16 +152,13 @@ MD5::operator() (
///////////////////////////////////////////////////////////////////////////////
std::array<uint32_t,4>
std::array<u32,4>
MD5::transform (
const std::array<uint32_t,4> &ABCD,
const std::array<uint32_t,16> &X) const noexcept
const std::array<u32,4> &ABCD,
const std::array<u32,16> &X) const noexcept
{
uint32_t A = ABCD[0],
B = ABCD[1],
C = ABCD[2],
D = ABCD[3];
auto [A,B,C,D] = ABCD;
#define ROUNDx(a,b,c,d,k,s,i,f) do { \
(a) += (f)((b), (c), (d)) + X[k] + T[i]; \