298 lines
7.6 KiB
C++
298 lines
7.6 KiB
C++
#ifndef CHAOS_HASH_SHA1_HPP
|
|
#define CHAOS_HASH_SHA1_HPP
|
|
|
|
#include <cstdint>
|
|
#include <array>
|
|
#include <string>
|
|
|
|
#include "Hash.hpp"
|
|
#include "Hasher.hpp"
|
|
|
|
namespace Chaos::Hash::Sha1::Inner_
|
|
{
|
|
|
|
struct Buffer
|
|
{
|
|
uint32_t Regs_[5] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 };
|
|
};
|
|
|
|
using Block = std::array<uint32_t, 16>;
|
|
|
|
struct Algorithm
|
|
{
|
|
public:
|
|
static void UpdateBuffer(Buffer & buffer, const Block & block)
|
|
{
|
|
static_assert(std::tuple_size_v<ScheduledBlock> == 80);
|
|
|
|
ScheduledBlock scheduled;
|
|
ScheduleBlock(scheduled, block);
|
|
|
|
uint32_t a = buffer.Regs_[0];
|
|
uint32_t b = buffer.Regs_[1];
|
|
uint32_t c = buffer.Regs_[2];
|
|
uint32_t d = buffer.Regs_[3];
|
|
uint32_t e = buffer.Regs_[4];
|
|
|
|
for (int_fast8_t i = 0; i < 20; ++i)
|
|
{
|
|
PerformRound(a, b, c, d, e, F0, scheduled[i], 0x5a827999);
|
|
}
|
|
|
|
for (int_fast8_t i = 20; i < 40; ++i)
|
|
{
|
|
PerformRound(a, b, c, d, e, F20, scheduled[i], 0x6ed9eba1);
|
|
}
|
|
|
|
for (int_fast8_t i = 40; i < 60; ++i)
|
|
{
|
|
PerformRound(a, b, c, d, e, F40, scheduled[i], 0x8f1bbcdc);
|
|
}
|
|
|
|
for (int_fast8_t i = 60; i < 80; ++i)
|
|
{
|
|
PerformRound(a, b, c, d, e, F60, scheduled[i], 0xca62c1d6);
|
|
}
|
|
|
|
buffer.Regs_[0] += a;
|
|
buffer.Regs_[1] += b;
|
|
buffer.Regs_[2] += c;
|
|
buffer.Regs_[3] += d;
|
|
buffer.Regs_[4] += e;
|
|
}
|
|
|
|
private:
|
|
using ScheduledBlock = std::array<uint32_t, 80>;
|
|
using RoundFunction = uint32_t (*)(uint32_t b, uint32_t c, uint32_t d);
|
|
|
|
static uint32_t Rotl(uint32_t v, int_fast8_t s)
|
|
{
|
|
return (v << s) | (v >> (32 - s));
|
|
}
|
|
|
|
static uint32_t F0(uint32_t b, uint32_t c, uint32_t d)
|
|
{
|
|
return (b & c) | ((~b) & d);
|
|
}
|
|
|
|
static uint32_t F20(uint32_t b, uint32_t c, uint32_t d)
|
|
{
|
|
return b ^ c ^ d;
|
|
}
|
|
|
|
static uint32_t F40(uint32_t b, uint32_t c, uint32_t d)
|
|
{
|
|
return (b & c) | (b & d) | (c & d);
|
|
}
|
|
|
|
static uint32_t F60(uint32_t b, uint32_t c, uint32_t d)
|
|
{
|
|
return b ^ c ^ d;
|
|
}
|
|
|
|
static void ScheduleBlock(ScheduledBlock & result, const Block & block)
|
|
{
|
|
static_assert(std::tuple_size_v<Block> == 16);
|
|
static_assert(std::tuple_size_v<ScheduledBlock> == 80);
|
|
|
|
std::copy(block.begin(), block.end(), result.begin());
|
|
|
|
for (int_fast8_t t = 16; t < 80; ++t)
|
|
{
|
|
result[t] = Rotl(result[t - 3] ^
|
|
result[t - 8] ^
|
|
result[t - 14] ^
|
|
result[t - 16], 1);
|
|
}
|
|
}
|
|
|
|
static void PerformRound(uint32_t & a, uint32_t & b, uint32_t & c,
|
|
uint32_t & d, uint32_t & e,
|
|
RoundFunction func, uint32_t data, uint32_t k)
|
|
{
|
|
const uint32_t temp = Rotl(a, 5) + func(b, c, d) + e + data + k;
|
|
|
|
e = d;
|
|
d = c;
|
|
c = Rotl(b, 30);
|
|
b = a;
|
|
a = temp;
|
|
}
|
|
};
|
|
|
|
} // namespace Chaos::Hash::Sha1::Inner_
|
|
|
|
namespace Chaos::Hash::Sha1
|
|
{
|
|
|
|
struct Sha1Hash : public Hash<Sha1Hash>
|
|
{
|
|
std::array<uint8_t, 20> GetRawDigest() const
|
|
{
|
|
return RawDigest_;
|
|
}
|
|
|
|
std::string ToHexString() const
|
|
{
|
|
char buf[41];
|
|
|
|
std::sprintf(buf,
|
|
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x"
|
|
"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
|
|
RawDigest_[ 0], RawDigest_[ 1], RawDigest_[ 2], RawDigest_[ 3],
|
|
RawDigest_[ 4], RawDigest_[ 5], RawDigest_[ 6], RawDigest_[ 7],
|
|
RawDigest_[ 8], RawDigest_[ 9], RawDigest_[10], RawDigest_[11],
|
|
RawDigest_[12], RawDigest_[13], RawDigest_[14], RawDigest_[15],
|
|
RawDigest_[16], RawDigest_[17], RawDigest_[18], RawDigest_[19]);
|
|
|
|
return std::string(buf, buf + 40);
|
|
}
|
|
|
|
std::array<uint8_t, 20> RawDigest_;
|
|
};
|
|
|
|
class Sha1Hasher : public Hasher<Sha1Hasher>
|
|
{
|
|
public:
|
|
using HashType = Sha1Hash;
|
|
|
|
static constexpr size_t BLOCK_SIZE_BYTES = 64;
|
|
|
|
Sha1Hasher()
|
|
{
|
|
ResetImpl();
|
|
}
|
|
|
|
void Reset()
|
|
{
|
|
ResetImpl();
|
|
}
|
|
|
|
template<typename InputIt>
|
|
void Update(InputIt begin, InputIt end)
|
|
{
|
|
MessageSizeBytes_ += UpdateImpl(begin, end);
|
|
}
|
|
|
|
HashType Finish()
|
|
{
|
|
uint64_t messageSizeBytesMod64 = MessageSizeBytes_ % 64;
|
|
|
|
int_fast8_t paddingNeededBytes;
|
|
|
|
if (messageSizeBytesMod64 < 56)
|
|
{
|
|
paddingNeededBytes = 56 - messageSizeBytesMod64;
|
|
}
|
|
else if (messageSizeBytesMod64 > 56)
|
|
{
|
|
paddingNeededBytes = 120 - messageSizeBytesMod64;
|
|
}
|
|
else
|
|
{
|
|
paddingNeededBytes = 64;
|
|
}
|
|
|
|
UpdateImpl(PAD_, PAD_ + paddingNeededBytes);
|
|
|
|
const uint64_t messageSizeBits = MessageSizeBytes_ * 8;
|
|
|
|
uint8_t encodedMessageSizeBits[] =
|
|
{
|
|
static_cast<uint8_t>((messageSizeBits >> 56) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 48) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 40) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 32) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 24) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 16) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 8) & 0xFF),
|
|
static_cast<uint8_t>((messageSizeBits >> 0) & 0xFF),
|
|
};
|
|
|
|
static_assert(std::size(encodedMessageSizeBits) == 8);
|
|
|
|
UpdateImpl(encodedMessageSizeBits,
|
|
encodedMessageSizeBits + std::size(encodedMessageSizeBits));
|
|
|
|
HashType result;
|
|
|
|
int_fast8_t i = 0;
|
|
for (int_fast8_t reg = 0; reg < 5; ++reg)
|
|
{
|
|
for (int_fast8_t shift = 0; shift < 32; shift += 8)
|
|
{
|
|
result.RawDigest_[i++] = (Buffer_.Regs_[reg] >> (24 - shift)) & 0xFF;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private:
|
|
static constexpr uint8_t PAD_[] =
|
|
{
|
|
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
static_assert(std::size(PAD_) == 64);
|
|
|
|
Inner_::Buffer Buffer_;
|
|
|
|
Inner_::Block Block_;
|
|
int_fast8_t BlockSize_;
|
|
|
|
uint32_t Word_;
|
|
int_fast8_t WordBytesPacked_;
|
|
|
|
uint64_t MessageSizeBytes_;
|
|
|
|
void ResetImpl()
|
|
{
|
|
Buffer_ = Inner_::Buffer();
|
|
Block_.fill(0);
|
|
|
|
BlockSize_ = 0;
|
|
Word_ = 0;
|
|
WordBytesPacked_ = 0;
|
|
MessageSizeBytes_ = 0;
|
|
}
|
|
|
|
template<typename InputIt>
|
|
uint64_t UpdateImpl(InputIt begin, InputIt end)
|
|
{
|
|
uint64_t written = 0;
|
|
|
|
for (InputIt it = begin; it != end; ++it, ++written)
|
|
{
|
|
Word_ |= (static_cast<uint32_t>(*it) << (24 - (WordBytesPacked_ * 8)));
|
|
++WordBytesPacked_;
|
|
|
|
if (WordBytesPacked_ == 4)
|
|
{
|
|
Block_[BlockSize_++] = Word_;
|
|
WordBytesPacked_ = 0;
|
|
Word_ = 0;
|
|
|
|
if (BlockSize_ == 16)
|
|
{
|
|
Inner_::Algorithm::UpdateBuffer(Buffer_, Block_);
|
|
BlockSize_ = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return written;
|
|
}
|
|
};
|
|
|
|
} // namespace Chaos::Hash::Sha1
|
|
|
|
#endif // CHAOS_HASH_SHA1_HPP
|