arachne::crypto::sha256_hasher Class Reference

#include <include/arachne/crypto.hpp>

Public Member Functions
	sha256_hasher () noexcept
void	reset () noexcept
void	update (std::span< const std::byte > bytes)
void	update (std::string_view bytes)
sha256_digest	finish ()
std::string	finish_hex ()

Private Member Functions
void	transform (const std::byte *block) noexcept

Private Attributes
std::array< std::uint32_t, 8 >	state_ {}
std::array< std::byte, 64 >	buffer_ {}
std::uint64_t	bit_count_ = 0
std::size_t	buffered_ = 0
bool	finished_ = false
sha256_digest	digest_ {}

Detailed Description

Incremental SHA-256 calculator.

Definition at line 17 of file crypto.hpp.

Constructor & Destructor Documentation

sha256_hasher()

arachne::crypto::sha256_hasher::sha256_hasher ( )

noexcept

Definition at line 64 of file crypto.cpp.

{ reset(); }

References reset().

Here is the call graph for this function:

Member Function Documentation

finish()

sha256_digest arachne::crypto::sha256_hasher::finish ( )

nodiscard

Finalize the digest. Repeated calls return the same value.

Definition at line 117 of file crypto.cpp.

                                    {
    if (finished_) {
        return digest_;
    }
 
    const std::uint64_t original_bit_count = bit_count_;
    buffer_[buffered_++] = std::byte { 0x80 };
    if (buffered_ > 56U) {
        std::fill(
            buffer_.begin() + static_cast<std::ptrdiff_t>(buffered_),
            buffer_.end(), std::byte { 0 }
        );
        transform(buffer_.data());
        buffered_ = 0;
    }
    std::fill(
        buffer_.begin() + static_cast<std::ptrdiff_t>(buffered_),
        buffer_.begin() + 56, std::byte { 0 }
    );
    for (std::size_t index = 0; index < 8U; ++index) {
        const unsigned shift = static_cast<unsigned>((7U - index) * 8U);
        buffer_[56U + index]
            = static_cast<std::byte>(original_bit_count >> shift);
    }
    transform(buffer_.data());
 
    for (std::size_t index = 0; index < state_.size(); ++index) {
        store_be32(digest_.data() + index * 4U, state_[index]);
    }
    finished_ = true;
    buffered_ = 0;
    return digest_;
}

References bit_count_, buffered_, and finished_.

finish_hex()

std::string arachne::crypto::sha256_hasher::finish_hex ( )

nodiscard

Definition at line 151 of file crypto.cpp.

{ return to_hex(finish()); }

Referenced by arachne::pheidippides::anonymous_namespace{transport.cpp}::verified_body_file::open_and_verify(), arachne::crypto::sha256(), arachne::crypto::sha256(), and arachne::crypto::sha256_file().

Here is the caller graph for this function:

reset()

void arachne::crypto::sha256_hasher::reset ( )

noexcept

Definition at line 66 of file crypto.cpp.

                                   {
    state_ = { 0x6a09e667U, 0xbb67ae85U, 0x3c6ef372U, 0xa54ff53aU,
               0x510e527fU, 0x9b05688cU, 0x1f83d9abU, 0x5be0cd19U };
    buffer_.fill(std::byte { 0 });
    digest_.fill(std::byte { 0 });
    bit_count_ = 0;
    buffered_ = 0;
    finished_ = false;
}

References bit_count_, buffered_, and finished_.

Referenced by sha256_hasher().

Here is the caller graph for this function:

transform()

void arachne::crypto::sha256_hasher::transform ( const std::byte * block )

privatenoexcept

Definition at line 153 of file crypto.cpp.

                                                                 {
    std::array<std::uint32_t, 64> schedule {};
    for (std::size_t index = 0; index < 16U; ++index) {
        schedule[index] = load_be32(block + index * 4U);
    }
    for (std::size_t index = 16; index < schedule.size(); ++index) {
        const std::uint32_t s0 = std::rotr(schedule[index - 15U], 7)
            ^ std::rotr(schedule[index - 15U], 18)
            ^ (schedule[index - 15U] >> 3U);
        const std::uint32_t s1 = std::rotr(schedule[index - 2U], 17)
            ^ std::rotr(schedule[index - 2U], 19)
            ^ (schedule[index - 2U] >> 10U);
        schedule[index]
            = schedule[index - 16U] + s0 + schedule[index - 7U] + s1;
    }
 
    std::uint32_t a = state_[0];
    std::uint32_t b = state_[1];
    std::uint32_t c = state_[2];
    std::uint32_t d = state_[3];
    std::uint32_t e = state_[4];
    std::uint32_t f = state_[5];
    std::uint32_t g = state_[6];
    std::uint32_t h = state_[7];
 
    for (std::size_t index = 0; index < schedule.size(); ++index) {
        const std::uint32_t sum1
            = std::rotr(e, 6) ^ std::rotr(e, 11) ^ std::rotr(e, 25);
        const std::uint32_t choose = (e & f) ^ (~e & g);
        const std::uint32_t temporary1
            = h + sum1 + choose + round_constants[index] + schedule[index];
        const std::uint32_t sum0
            = std::rotr(a, 2) ^ std::rotr(a, 13) ^ std::rotr(a, 22);
        const std::uint32_t majority = (a & b) ^ (a & c) ^ (b & c);
        const std::uint32_t temporary2 = sum0 + majority;
 
        h = g;
        g = f;
        f = e;
        e = d + temporary1;
        d = c;
        c = b;
        b = a;
        a = temporary1 + temporary2;
    }
 
    state_[0] += a;
    state_[1] += b;
    state_[2] += c;
    state_[3] += d;
    state_[4] += e;
    state_[5] += f;
    state_[6] += g;
    state_[7] += h;
}

References arachne::crypto::anonymous_namespace{crypto.cpp}::load_be32().

Referenced by update().

Here is the call graph for this function:

Here is the caller graph for this function:

update() [1/2]

void arachne::crypto::sha256_hasher::update

(

std::span< const std::byte >

bytes

)

Definition at line 76 of file crypto.cpp.

                                                             {
    if (finished_) {
        throw std::logic_error("cannot update a finalized SHA-256 digest");
    }
    constexpr std::uint64_t max_bytes
        = std::numeric_limits<std::uint64_t>::max() / 8U;
    if (bytes.size() > max_bytes
        || static_cast<std::uint64_t>(bytes.size())
            > max_bytes - bit_count_ / 8U) {
        throw std::length_error("SHA-256 input exceeds its length encoding");
    }
    bit_count_ += static_cast<std::uint64_t>(bytes.size()) * 8U;
 
    std::size_t offset = 0;
    if (buffered_ != 0) {
        const std::size_t copied
            = std::min(buffer_.size() - buffered_, bytes.size());
        std::copy_n(bytes.data(), copied, buffer_.data() + buffered_);
        buffered_ += copied;
        offset += copied;
        if (buffered_ == buffer_.size()) {
            transform(buffer_.data());
            buffered_ = 0;
        }
    }
 
    while (bytes.size() - offset >= buffer_.size()) {
        transform(bytes.data() + offset);
        offset += buffer_.size();
    }
 
    if (offset != bytes.size()) {
        buffered_ = bytes.size() - offset;
        std::copy_n(bytes.data() + offset, buffered_, buffer_.data());
    }
}

References bit_count_, buffered_, finished_, and transform().

Here is the call graph for this function:

update() [2/2]

void arachne::crypto::sha256_hasher::update

(

std::string_view

bytes

)

Definition at line 113 of file crypto.cpp.

                                                     {
    update(std::as_bytes(std::span { bytes.data(), bytes.size() }));
}

Member Data Documentation

bit_count_

std::uint64_t arachne::crypto::sha256_hasher::bit_count_ = 0

private

Definition at line 34 of file crypto.hpp.

Referenced by finish(), reset(), and update().

buffer_

std::array<std::byte, 64> arachne::crypto::sha256_hasher::buffer_ {}

private

Definition at line 33 of file crypto.hpp.

{};

buffered_

std::size_t arachne::crypto::sha256_hasher::buffered_ = 0

private

Definition at line 35 of file crypto.hpp.

Referenced by finish(), reset(), and update().

digest_

sha256_digest arachne::crypto::sha256_hasher::digest_ {}

private

Definition at line 37 of file crypto.hpp.

{};

finished_

bool arachne::crypto::sha256_hasher::finished_ = false

private

Definition at line 36 of file crypto.hpp.

Referenced by finish(), reset(), and update().

state_

std::array<std::uint32_t, 8> arachne::crypto::sha256_hasher::state_ {}

private

Definition at line 32 of file crypto.hpp.

{};

---

The documentation for this class was generated from the following files:

• crypto.hpp
• crypto.cpp