picosha2::hash256_one_by_one Class Reference

#include <picosha2.h>

Collaboration diagram for picosha2::hash256_one_by_one:

Public Member Functions
	hash256_one_by_one ()
void	init ()
template<typename RaIter >
void	process (RaIter first, RaIter last)
void	finish ()
template<typename OutIter >
void	get_hash_bytes (OutIter first, OutIter last) const

Private Member Functions
void	add_to_data_length (word_t n)
void	write_data_bit_length (byte_t *begin)

Private Attributes
std::vector< byte_t >	m_buffer_
word_t	m_data_length_digits_ [4]
word_t	m_h_ [8]

Detailed Description

Definition at line 184 of file picosha2.h.

Constructor & Destructor Documentation

hash256_one_by_one()

picosha2::hash256_one_by_one::hash256_one_by_one ( )

inline

Definition at line 186 of file picosha2.h.

{init();}

Member Function Documentation

add_to_data_length()

void picosha2::hash256_one_by_one::add_to_data_length ( word_t  n )

inlineprivate

Definition at line 238 of file picosha2.h.

                                      {
      word_t carry = 0;
 
      m_data_length_digits_[0] += n;
      for (std::size_t i = 0; i < 4; ++i) {
        m_data_length_digits_[i] += carry;
        if (m_data_length_digits_[i] >= 65536u) {
          carry = m_data_length_digits_[i] >> 16;
          m_data_length_digits_[i] &= 65535u;
        } else {
          break;
        }
      }
    }

finish()

void picosha2::hash256_one_by_one::finish ( )

inline

Definition at line 207 of file picosha2.h.

                  {
      byte_t temp[64];
 
      std::fill(temp, temp + 64, 0);
      std::size_t remains = m_buffer_.size();
      std::copy(m_buffer_.begin(), m_buffer_.end(), temp);
      temp[remains] = 0x80;
 
      if (remains > 55) {
        std::fill(temp + remains + 1, temp + 64, 0);
        detail::hash256_block(m_h_, temp, temp + 64);
        std::fill(temp, temp + 64 - 4, 0);
      } else {
        std::fill(temp + remains + 1, temp + 64 - 4, 0);
      }
 
      write_data_bit_length(&(temp[56]));
      detail::hash256_block(m_h_, temp, temp + 64);
    }

get_hash_bytes()

template<typename OutIter >

void picosha2::hash256_one_by_one::get_hash_bytes ( OutIter  first, OutIter  last  ) const

inline

Definition at line 228 of file picosha2.h.

                                                           {
      for (const word_t* iter = m_h_; iter != m_h_ + 8; ++iter) {
        for (std::size_t i = 0; i < 4 && first != last; ++i) {
          *(first++) = detail::mask_8bit(
            static_cast<byte_t>((*iter >> (24 - 8 * i))));
        }
      }
    }

init()

void picosha2::hash256_one_by_one::init ( )

inline

Definition at line 188 of file picosha2.h.

                {
      m_buffer_.clear();
      std::fill(m_data_length_digits_, m_data_length_digits_ + 4, 0);
      std::copy(detail::initial_message_digest,
                detail::initial_message_digest + 8, m_h_);
    }

process()

template<typename RaIter >

void picosha2::hash256_one_by_one::process ( RaIter  first, RaIter  last  )

inline

Definition at line 196 of file picosha2.h.

                                            {
      add_to_data_length(static_cast<word_t>(std::distance(first, last)));
      std::copy(first, last, std::back_inserter(m_buffer_));
      std::size_t i = 0;
      for (; i + 64 <= m_buffer_.size(); i += 64) {
        detail::hash256_block(m_h_, m_buffer_.begin() + i,
                              m_buffer_.begin() + i + 64);
      }
      m_buffer_.erase(m_buffer_.begin(), m_buffer_.begin() + i);
    }

write_data_bit_length()

void picosha2::hash256_one_by_one::write_data_bit_length ( byte_t *  begin )

inlineprivate

Definition at line 253 of file picosha2.h.

                                              {
      word_t data_bit_length_digits[4];
 
      std::copy(m_data_length_digits_, m_data_length_digits_ + 4,
                data_bit_length_digits);
 
      // convert byte length to bit length (multiply 8 or shift 3 times left)
      word_t carry = 0;
      for (std::size_t i = 0; i < 4; ++i) {
        word_t before_val = data_bit_length_digits[i];
        data_bit_length_digits[i] <<= 3;
        data_bit_length_digits[i] |= carry;
        data_bit_length_digits[i] &= 65535u;
        carry = (before_val >> (16 - 3)) & 65535u;
      }
 
      // write data_bit_length
      for (int i = 3; i >= 0; --i) {
        (*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8);
        (*begin++) = static_cast<byte_t>(data_bit_length_digits[i]);
      }
    }

Member Data Documentation

m_buffer_

std::vector<byte_t> picosha2::hash256_one_by_one::m_buffer_

private

Definition at line 276 of file picosha2.h.

m_data_length_digits_

word_t picosha2::hash256_one_by_one::m_data_length_digits_[4]

private

Definition at line 277 of file picosha2.h.

m_h_

word_t picosha2::hash256_one_by_one::m_h_[8]

private

Definition at line 278 of file picosha2.h.

---

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

• picosha2.h