dnomd343
/
md5sum
mirror of https://github.com/dnomd343/md5sum.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

update: project structural adjustment

master
Dnomd343 8 months ago
parent
cc05bfec08
commit
d76adbf976
6 changed files with 81 additions and 42 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 29
      src/impl/algorithm.inc
  2. 26
      src/impl/constexpr.inc
  3. 4
      src/impl/core.cc
  4. 10
      src/impl/inline.inc
  5. 48
      src/impl/value.inc
  6. 6
      src/impl/wrapper.cc

29
src/impl/algorithm.inc
View File

@ -33,27 +33,15 @@
#define MD5_UPDATE \
MD5_ROUND(MD5_FF) MD5_ROUND(MD5_GG) MD5_ROUND(MD5_HH) MD5_ROUND(MD5_II)
#include "sine.inc"
#include "value.inc"
namespace md5::impl {
/// Hexadecimal character mapping table.
constexpr char HexTable[] = {
'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f',
};
/// MD5 fixed constants in little endian.
constexpr uint32_t MD5_A = 0x67452301;
constexpr uint32_t MD5_B = 0xefcdab89;
constexpr uint32_t MD5_C = 0x98badcfe;
constexpr uint32_t MD5_D = 0x10325476;
struct md5_ctx {
uint32_t A = MD5_A;
uint32_t B = MD5_B;
uint32_t C = MD5_C;
uint32_t D = MD5_D;
uint32_t A = value::kA;
uint32_t B = value::kB;
uint32_t C = value::kC;
uint32_t D = value::kD;
uint64_t size = 0; // processed size in byte
};
@ -77,8 +65,11 @@ constexpr int S(const int i) {
/// MD5 T-table constant, input between 0 and 63.
constexpr uint32_t T(const int i) {
const auto val = ::md5::math::sin(i + 1);
return static_cast<uint32_t>(::md5::math::abs(val) * 0x100000000);
return value::kT[i];
}
static_assert(K(0) != K(63), "invalid constexpr");
static_assert(S(0) != S(63), "invalid constexpr");
static_assert(T(0) != T(63), "invalid constexpr");
} // namespace md5::impl

26
src/impl/constexpr.inc
View File

@ -1,26 +1,24 @@
#pragma once
#include <array>
namespace md5::impl {
struct md5_ctx_ce {
uint32_t A = MD5_A;
uint32_t B = MD5_B;
uint32_t C = MD5_C;
uint32_t D = MD5_D;
uint32_t A = value::kA;
uint32_t B = value::kB;
uint32_t C = value::kC;
uint32_t D = value::kD;
const char *data;
uint64_t data_len, padded_len;
constexpr md5_ctx_ce(const char *data, uint64_t len)
constexpr md5_ctx_ce(const char *data, const uint64_t len)
: data(data), data_len(len), padded_len((len + 64 + 8) & ~0b111111ULL) {}
};
using Block = std::array<uint32_t, 16>; // single md5 block with 64 bytes
/// Get the data and padding byte of the specified index.
constexpr uint8_t GetByte(md5_ctx_ce *ctx, const uint64_t index) {
constexpr uint8_t GetByte(const md5_ctx_ce *ctx, const uint64_t index) {
if (index < ctx->data_len) // message data
return ctx->data[index];
if (index == ctx->data_len) // padding flag
@ -32,10 +30,10 @@ constexpr uint8_t GetByte(md5_ctx_ce *ctx, const uint64_t index) {
}
/// Get the MD5 block content at the specified index.
constexpr Block GetBlock(md5_ctx_ce *ctx, const uint64_t index) {
constexpr Block GetBlock(const md5_ctx_ce *ctx, const uint64_t index) {
Block block {};
for (int i = 0; i < 16; ++i) {
auto offset = index + i * 4;
const auto offset = index + i * 4;
(block[i] <<= 8) |= GetByte(ctx, offset + 3);
(block[i] <<= 8) |= GetByte(ctx, offset + 2);
(block[i] <<= 8) |= GetByte(ctx, offset + 1);
@ -45,13 +43,13 @@ constexpr Block GetBlock(md5_ctx_ce *ctx, const uint64_t index) {
}
/// Convert origin MD5 integers to hexadecimal character array.
constexpr std::array<char, 32> DigestCE(std::array<uint32_t, 4> ctx) {
constexpr std::array<char, 32> DigestCE(const std::array<uint32_t, 4> &ctx) {
std::array<char, 32> result {};
for (uint32_t i = 0, val = 0; i < 32; val >>= 8) {
if (!(i & 0b111))
val = ctx[i >> 3];
result[i++] = HexTable[(val >> 4) & 0b1111];
result[i++] = HexTable[val & 0b1111];
result[i++] = value::HexTable[(val >> 4) & 0b1111];
result[i++] = value::HexTable[val & 0b1111];
}
return result;
}
@ -73,4 +71,6 @@ constexpr std::array<char, 32> MD5::HashCE(const char *data, uint64_t len) {
return DigestCE({ctx.A, ctx.B, ctx.C, ctx.D});
}
static_assert(MD5::HashCE("")[0] == 'd', "invalid constexpr");
} // namespace md5::impl

4
src/impl/core.cc
View File

@ -33,7 +33,7 @@ const void* MD5::UpdateImpl(const void *data, uint64_t len) {
ctx_.C = C;
ctx_.D = D;
ctx_.size += len;
return static_cast<const void *>(limit);
return limit;
}
void MD5::FinalImpl(const void *data, uint64_t len) {
@ -44,7 +44,7 @@ void MD5::FinalImpl(const void *data, uint64_t len) {
unsigned char buffer[128]; // 2 blocks
::std::memcpy(buffer, data, len);
uint64_t total = (ctx_.size + len) << 3; // total number in bit
const uint64_t total = (ctx_.size + len) << 3; // total number in bit
if (len < 56) { // len -> [0, 56)
::std::memcpy(buffer + len, Padding, 56 - len);

10
src/impl/inline.inc
View File

@ -3,10 +3,10 @@
namespace md5::impl {
inline MD5& MD5::Reset() {
ctx_.A = MD5_A;
ctx_.B = MD5_B;
ctx_.C = MD5_C;
ctx_.D = MD5_D;
ctx_.A = value::kA;
ctx_.B = value::kB;
ctx_.C = value::kC;
ctx_.D = value::kD;
ctx_.size = 0;
buffer_size_ = 0;
return *this;
@ -25,7 +25,7 @@ inline std::string MD5::Hash(const std::string_view &data) {
return Hash(data.data(), data.size());
}
inline std::string MD5::Hash(const void *data, uint64_t len) {
inline std::string MD5::Hash(const void *data, const uint64_t len) {
MD5 md5;
md5.FinalImpl(data, len);
return md5.Digest();

48
src/impl/value.inc
View File

@ -0,0 +1,48 @@
#pragma once
#include "sine.inc"
namespace md5::value {
/// Hexadecimal character mapping table.
constexpr char HexTable[] = {
'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f',
};
/// MD5 fixed constants in little endian.
constexpr uint32_t kA = 0x67452301;
constexpr uint32_t kB = 0xefcdab89;
constexpr uint32_t kC = 0x98badcfe;
constexpr uint32_t kD = 0x10325476;
// In order to be compatible with C++17, the `consteval` keyword cannot be used
// here. The MD5 T-table constants will be macro-expanded and calculated.
constexpr uint32_t TCal(const int i) {
const auto val = math::sin(i + 1);
return static_cast<uint32_t>(math::abs(val) * 0x100000000);
}
#define MD5_TT \
MD5_T(00) MD5_T(01) MD5_T(02) MD5_T(03) MD5_T(04) MD5_T(05) MD5_T(06) MD5_T(07) \
MD5_T(08) MD5_T(09) MD5_T(0a) MD5_T(0b) MD5_T(0c) MD5_T(0d) MD5_T(0e) MD5_T(0f) \
MD5_T(10) MD5_T(11) MD5_T(12) MD5_T(13) MD5_T(14) MD5_T(15) MD5_T(16) MD5_T(17) \
MD5_T(18) MD5_T(19) MD5_T(1a) MD5_T(1b) MD5_T(1c) MD5_T(1d) MD5_T(1e) MD5_T(1f) \
MD5_T(20) MD5_T(21) MD5_T(22) MD5_T(23) MD5_T(24) MD5_T(25) MD5_T(26) MD5_T(27) \
MD5_T(28) MD5_T(29) MD5_T(2a) MD5_T(2b) MD5_T(2c) MD5_T(2d) MD5_T(2e) MD5_T(2f) \
MD5_T(30) MD5_T(31) MD5_T(32) MD5_T(33) MD5_T(34) MD5_T(35) MD5_T(36) MD5_T(37) \
MD5_T(38) MD5_T(39) MD5_T(3a) MD5_T(3b) MD5_T(3c) MD5_T(3d) MD5_T(3e) MD5_T(3f)
#define MD5_T(x) constexpr auto kT_##x = TCal(0x##x);
MD5_TT
#undef MD5_T
#define MD5_T(x) kT_##x,
/// MD5 T-table constant array.
constexpr std::array kT = {MD5_TT};
#undef MD5_T
#undef MD5_TT
} // namespace md5::value

6
src/impl/wrapper.cc
View File

@ -8,8 +8,8 @@ std::string MD5::Digest() const {
std::string result(32, 0x00);
auto *ptr = reinterpret_cast<const uint8_t *>(&ctx_);
for (int i = 0; i < 32; ++ptr) {
result[i++] = HexTable[*ptr >> 4];
result[i++] = HexTable[*ptr & 0b1111];
result[i++] = value::HexTable[*ptr >> 4];
result[i++] = value::HexTable[*ptr & 0b1111];
}
return result;
}
@ -22,7 +22,7 @@ MD5& MD5::Update(const void *data, uint64_t len) {
return *this; // save into buffer and return
}
auto size = 64 - buffer_size_;
const auto size = 64 - buffer_size_;
::std::memcpy(buffer_ + buffer_size_, data, size);
UpdateImpl(buffer_, 64); // fill and update with buffer
data = static_cast<const char*>(data) + size;

Write Preview
Loading…
Cancel
Save