quickcpplib::_xxx::algorithm::hash::sha256_hash Class Reference

SHA256 hash. More...

#include "hash.hpp"

Classes
union	result_type
	The result type of the hash. More...

Public Member Functions
constexpr	sha256_hash () noexcept
	Initialise the hash.
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
void	add (const T *data, size_t bytes) noexcept
	Hash input.
result_type	finalise () noexcept
	Finalise and return hash.

Static Public Member Functions
template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>
static constexpr result_type	hash (const T *data, size_t bytes) noexcept
	Single shot hash of a sequence of bytes.

Detailed Description

SHA256 hash.

Constructor & Destructor Documentation

sha256_hash()

constexpr quickcpplib::_xxx::algorithm::hash::sha256_hash::sha256_hash ( )

inlineconstexprnoexcept

Initialise the hash.

{}

Member Function Documentation

add()

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>

void quickcpplib::_xxx::algorithm::hash::sha256_hash::add ( const T *  data, size_t  bytes  )

inlinenoexcept

Hash input.

      {
        static const uint32_t *const k = _k();
        /*
         * Note 1: All integers (expect indexes) are 32-bit unsigned integers and addition is calculated modulo 2^32.
         * Note 2: For each round, there is one round constant k[i] and one entry in the message schedule array w[i], 0 = i = 63
         * Note 3: The compression function uses 8 working variables, a through h
         * Note 4: Big-endian convention is used when expressing the constants in this pseudocode,
         *     and when parsing message block data from bytes to words, for example,
         *     the first word of the input message "abc" after padding is 0x61626380
         */
        while(const uint8_t *p = _calc_chunk(data, bytes))
        {
          /* Note that if we ever do support CPUID detection for the Intel SHA extensions, there is a public domain
          implementation of the SHA256 rounds at https://github.com/noloader/SHA-Intrinsics/blob/master/sha256-x86.c
          */
          alignas(32) uint32_t ah[8];
 
          /* Initialize working variables to current hash value: */
          memcpy(ah, _h.as_ints, sizeof(ah));
 
          /*
           * create a 64-entry message schedule array w[0..63] of 32-bit words
           * copy chunk into first 16 words w[0..15] of the message schedule array
           */
          alignas(32) uint32_t w[64];
          for(unsigned i = 0; i < 16; i++)
          {
            w[i] = ((uint32_t) p[0] << 24) | ((uint32_t) p[1] << 16) | ((uint32_t) p[2] << 8) | ((uint32_t) p[3]);
            p += 4;
          }
          /* Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array: */
          for(unsigned i = 16; i < 64; i++)
          {
            const uint32_t s0 = _right_rot(w[i - 15], 7) ^ _right_rot(w[i - 15], 18) ^ (w[i - 15] >> 3);
            const uint32_t s1 = _right_rot(w[i - 2], 17) ^ _right_rot(w[i - 2], 19) ^ (w[i - 2] >> 10);
            w[i] = w[i - 16] + s0 + w[i - 7] + s1;
          }
 
          /* Compression function main loop: */
          for(unsigned i = 0; i < 64; i++)
          {
            const uint32_t s1 = _right_rot(ah[4], 6) ^ _right_rot(ah[4], 11) ^ _right_rot(ah[4], 25);
            const uint32_t ch = (ah[4] & ah[5]) ^ (~ah[4] & ah[6]);
            const uint32_t temp1 = ah[7] + s1 + ch + k[i] + w[i];
            const uint32_t s0 = _right_rot(ah[0], 2) ^ _right_rot(ah[0], 13) ^ _right_rot(ah[0], 22);
            const uint32_t maj = (ah[0] & ah[1]) ^ (ah[0] & ah[2]) ^ (ah[1] & ah[2]);
            const uint32_t temp2 = s0 + maj;
 
            ah[7] = ah[6];
            ah[6] = ah[5];
            ah[5] = ah[4];
            ah[4] = ah[3] + temp1;
            ah[3] = ah[2];
            ah[2] = ah[1];
            ah[1] = ah[0];
            ah[0] = temp1 + temp2;
          }
 
          /* Add the compressed chunk to the current hash value: */
          for(unsigned i = 0; i < 8; i++)
            _h.as_ints[i] += ah[i];
        }
      }

finalise()

result_type quickcpplib::_xxx::algorithm::hash::sha256_hash::finalise ( )

inlinenoexcept

Finalise and return hash.

      {
        /*
         * Now:
         * - either there is enough space left for the total length, and we can conclude,
         * - or there is too little space left, and we have to pad the rest of this chunk with zeroes.
         * In the latter case, we will conclude at the next invokation of this function.
         */
        size_t space_in_chunk = _CHUNK_SIZE - _chunkidx;
        assert(space_in_chunk > 0);
        _chunk[_chunkidx++] = 0x80;
        space_in_chunk--;
        if(space_in_chunk < _TOTAL_LEN_LEN)
        {
          memory::cmemset(_chunk + _chunkidx, (uint8_t) 0, space_in_chunk);
          _chunkidx += space_in_chunk;
          assert(_chunkidx == _CHUNK_SIZE);
          add((const uint8_t *) nullptr, 0);
          assert(_chunkidx == 0);
          space_in_chunk = _CHUNK_SIZE - _chunkidx;
        }
        assert(space_in_chunk >= _TOTAL_LEN_LEN);
 
        const size_t left = space_in_chunk - _TOTAL_LEN_LEN;
        memory::cmemset(_chunk + _chunkidx, (uint8_t) 0, left);
        _chunkidx += left;
 
        /* Storing of len * 8 as a big endian 64-bit without overflow. */
        size_t len = _total_len;
        _chunk[_chunkidx + 7] = (uint8_t) ((len << 3) & 0xff);
        len >>= 5;
        for(int i = 6; i >= 0; i--)
        {
          _chunk[_chunkidx + i] = (uint8_t) (len & 0xff);
          len >>= 8;
        }
        _chunkidx += 8;
        assert(_chunkidx == _CHUNK_SIZE);
        add((const uint8_t *) nullptr, 0);
        assert(_chunkidx == 0);
 
        result_type ret;
        /* Produce the final hash value (big-endian): */
        for(unsigned i = 0, j = 0; i < 8; i++)
        {
          ret.as_bytes[j++] = (uint8_t) ((_h.as_ints[i] >> 24) & 0xff);
          ret.as_bytes[j++] = (uint8_t) ((_h.as_ints[i] >> 16) & 0xff);
          ret.as_bytes[j++] = (uint8_t) ((_h.as_ints[i] >> 8) & 0xff);
          ret.as_bytes[j++] = (uint8_t) (_h.as_ints[i] & 0xff);
        }
        _h = result_type{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
        _chunkidx = _total_len = 0;
        return ret;
      }

hash()

template<class T , typename std::enable_if<(sizeof(T)==1), bool >::type = true, typename std::enable_if<(std::is_trivially_copyable< T >::value), bool >::type = true>

static constexpr result_type quickcpplib::_xxx::algorithm::hash::sha256_hash::hash ( const T *  data, size_t  bytes  )

inlinestaticconstexprnoexcept

Single shot hash of a sequence of bytes.

      {
        sha256_hash ret;
        ret.add(data, bytes);
        return ret.finalise();
      }

---

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

• include/quickcpplib/algorithm/hash.hpp