Hash function

Step 1

cmake_minimum_required(VERSION 3.20)
project(dixl_hash_engine VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_library(hash_engine STATIC src/hash_engine.cpp)
target_include_directories(hash_engine PUBLIC include)
target_compile_options(hash_engine PRIVATE -Wall -Wextra -Werror -O3 -march=native)

Step 2

#ifndef DIXL_HASH_ENGINE_H
#define DIXL_HASH_ENGINE_H

#include <cstdint>
#include <cstddef>

namespace dixl {

class HashEngine {
public:
    static constexpr uint64_t PRIME_CONST_1 = 0xc6a4a7935bd1e995ULL;
    static constexpr uint64_t PRIME_CONST_2 = 0x65e7144444583948ULL;

    [[nodiscard]] static constexpr uint64_t murmur_mix_64(const void* data, size_t len, uint64_t seed = 0x5bd1e995) noexcept {
        const auto* const bytes = static_cast<const uint8_t*>(data);
        const int nblocks = static_cast<int>(len / 8);
        uint64_t h = seed ^ (len * PRIME_CONST_1);

        const auto* const blocks = reinterpret_cast<const uint64_t*>(bytes);
        for (int i = 0; i < nblocks; ++i) {
            uint64_t k = blocks[i];
            k *= PRIME_CONST_1;
            k ^= k >> 47;
            k *= PRIME_CONST_1;

            h ^= k;
            h *= PRIME_CONST_1;
        }

        const auto* const tail = reinterpret_cast<const uint8_t*>(bytes + (nblocks * 8));
        uint64_t k1 = 0;

        switch (len & 7) {
            case 7: k1 ^= static_cast<uint64_t>(tail[6]) << 48; [[fallthrough]];
            case 6: k1 ^= static_cast<uint64_t>(tail[5]) << 40; [[fallthrough]];
            case 5: k1 ^= static_cast<uint64_t>(tail[4]) << 32; [[fallthrough]];
            case 4: k1 ^= static_cast<uint64_t>(tail[3]) << 24; [[fallthrough]];
            case 3: k1 ^= static_cast<uint64_t>(tail[2]) << 16; [[fallthrough]];
            case 2: k1 ^= static_cast<uint64_t>(tail[1]) << 8;  [[fallthrough]];
            case 1: 
                k1 ^= static_cast<uint64_t>(tail[0]);
                k1 *= PRIME_CONST_1;
                k1 ^= k1 >> 47;
                k1 *= PRIME_CONST_1;
                h ^= k1;
                h *= PRIME_CONST_1;
        }

        h ^= h >> 47;
        h *= PRIME_CONST_2;
        h ^= h >> 47;

        return h;
    }
};

} // namespace dixl
#endif // DIXL_HASH_ENGINE_H

Step 3

#include <gtest/gtest.h>
#include "hash_engine.hpp"
#include <string>
#include <vector>

TEST(HashEngineTests, ZeroLengthInput) {
    std::string empty = "";
    uint64_t hash1 = dixl::HashEngine::murmur_mix_64(empty.data(), empty.size());
    uint64_t hash2 = dixl::HashEngine::murmur_mix_64(empty.data(), empty.size());
    EXPECT_EQ(hash1, hash2);
}

TEST(HashEngineTests, AvalancheEffect) {
    std::string s1 = "dixl_developer_lexicon";
    std::string s2 = "dixl_developer_lexicoi"; // 1 bit difference
    
    uint64_t h1 = dixl::HashEngine::murmur_mix_64(s1.data(), s1.size());
    uint64_t h2 = dixl::HashEngine::murmur_mix_64(s2.data(), s2.size());
    
    EXPECT_NE(h1, h2);

    uint64_t diff = h1 ^ h2;
    int set_bits = 0;
    while (diff) {
        set_bits += diff & 1;
        diff >>= 1;
    }
    // Expect roughly 50% bit flips (avalanche criterion)
    EXPECT_GE(set_bits, 16);
    EXPECT_LE(set_bits, 48);
}

Step 4

#include <random>
#include <stdexcept>

namespace dixl {

class SecuredHashContext {
private:
    uint64_t process_entropy_seed_;

public:
    SecuredHashContext() {
        std::random_device rd;
        std::mt19937_64 gen(rd());
        std::uniform_int_distribution<uint64_t> dis;
        process_entropy_seed_ = dis(gen);
    }

    [[nodiscard]] uint64_t compute(const void* data, size_t size) const {
        if (data == nullptr && size > 0) {
            throw std::invalid_argument("Null pointer provided with non-zero size.");
        }
        return HashEngine::murmur_mix_64(data, size, process_entropy_seed_);
    }
};

} // namespace dixl