fc::sha256 Class Reference

#include <sha256.hpp>

Inheritance diagram for fc::sha256:

Classes
class	encoder

Public Member Functions
	sha256 ()
	sha256 (const string &hex_str)
	sha256 (const char *data, size_t size)
string	str () const
	operator string () const
const char *	data () const
char *	data ()
size_t	data_size () const
uint32_t	pop_count () const
uint16_t	clz () const
uint32_t	approx_log_32 () const
void	set_to_inverse_approx_log_32 (uint32_t x)

Static Public Member Functions
static sha256	hash (const char *d, uint32_t dlen)
static sha256	hash (const string &)
static sha256	hash (const sha256 &)
template<typename T >
static sha256	hash (const T &t)
static double	inverse_approx_log_32_double (uint32_t x)

Public Attributes
uint64_t	_hash [4]

Friends
template<typename T >
T &	operator<< (T &ds, const sha256 &ep)
template<typename T >
T &	operator>> (T &ds, sha256 &ep)
sha256	operator<< (const sha256 &h1, uint32_t i)
sha256	operator>> (const sha256 &h1, uint32_t i)
bool	operator== (const sha256 &h1, const sha256 &h2)
bool	operator!= (const sha256 &h1, const sha256 &h2)
sha256	operator^ (const sha256 &h1, const sha256 &h2)
bool	operator>= (const sha256 &h1, const sha256 &h2)
bool	operator> (const sha256 &h1, const sha256 &h2)
bool	operator< (const sha256 &h1, const sha256 &h2)

Detailed Description

Definition at line 11 of file sha256.hpp.

Constructor & Destructor Documentation

sha256() [1/3]

fc::sha256::sha256

(

)

Definition at line 14 of file sha256.cpp.

{ memset( _hash, 0, sizeof(_hash) ); }

Here is the call graph for this function:

sha256() [2/3]

fc::sha256::sha256 ( const string & hex_str )

explicit

Definition at line 20 of file sha256.cpp.

                                          {
      auto bytes_written = fc::from_hex( hex_str, (char*)_hash, sizeof(_hash) );
      if( bytes_written < sizeof(_hash) )
         memset( (char*)_hash + bytes_written, 0, (sizeof(_hash) - bytes_written) );
    }

Here is the call graph for this function:

sha256() [3/3]

fc::sha256::sha256 ( const char * data, size_t size )

explicit

Definition at line 15 of file sha256.cpp.

                                                  {
       if (size != sizeof(_hash))
      FC_THROW_EXCEPTION( exception, "sha256: size mismatch" );
       memcpy(_hash, data, size );
    }

Here is the call graph for this function:

Member Function Documentation

approx_log_32()

uint32_t fc::sha256::approx_log_32

(

)

const

Approximate (log_2(x) + 1) * 2**24.

Detailed specs:

• Return 0 when x == 0.
• High 8 bits of result simply counts nonzero bits.
• Low 24 bits of result are the 24 bits of input immediately after the most significant 1 in the input.
• If above would require reading beyond the end of the input, zeros are used instead.

Definition at line 111 of file sha256.cpp.

   {
      uint16_t lzbits = clz();
      if( lzbits >= 0x100 )
         return 0;
      uint8_t nzbits = 0xFF-lzbits;
      size_t offset = (size_t) (lzbits >> 3);
      uint8_t* my_bytes = (uint8_t*) data();
      size_t n = data_size();
      uint32_t y = (uint32_t(               my_bytes[offset  ]    ) << 0x18)
                 | (uint32_t(offset+1 < n ? my_bytes[offset+1] : 0) << 0x10)
                 | (uint32_t(offset+2 < n ? my_bytes[offset+2] : 0) << 0x08)
                 | (uint32_t(offset+3 < n ? my_bytes[offset+3] : 0)        )
                 ;
      //
      // lzbits&7 == 7 : 00000001 iff nzbits&7 == 0
      // lzbits&7 == 6 : 0000001x iff nzbits&7 == 1
      // lzbits&7 == 5 : 000001xx iff nzbits&7 == 2
      //
      y >>= (nzbits & 7);
      y ^= 1 << 0x18;
      y |= uint32_t( nzbits ) << 0x18;
      return y;
   }

Here is the call graph for this function:

clz()

uint16_t fc::sha256::clz

(

)

const

Count leading zero bits

Definition at line 173 of file sha256.cpp.

   {
      const uint8_t* my_bytes = (uint8_t*) data();
      size_t size = data_size();
      size_t lzbits = 0;
      static const uint8_t char2lzbits[] = {
     // 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
        8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
       };
 
      size_t i = 0;
 
      while( true )
      {
         uint8_t c = my_bytes[i];
         lzbits += char2lzbits[c];
         if( c != 0 )
            break;
         ++i;
         if( i >= size )
            return 0x100;
      }
 
      return lzbits;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

data() [1/2]

char * fc::sha256::data

(

)

Definition at line 32 of file sha256.cpp.

{ return (char*)&_hash[0]; }

data() [2/2]

const char * fc::sha256::data

(

)

const

Definition at line 31 of file sha256.cpp.

{ return (const char*)&_hash[0]; }

Here is the caller graph for this function:

data_size()

size_t fc::sha256::data_size ( ) const

inline

Definition at line 23 of file sha256.hpp.

{ return 256 / 8; }

Here is the caller graph for this function:

hash() [1/4]

sha256 fc::sha256::hash ( const char * d, uint32_t dlen )

static

Definition at line 44 of file sha256.cpp.

                                                      {
      encoder e;
      e.write(d,dlen);
      return e.result();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

hash() [2/4]

sha256 fc::sha256::hash ( const sha256 & s )

static

Definition at line 54 of file sha256.cpp.

    {
        return hash( s.data(), sizeof( s._hash ) );
    }

Here is the call graph for this function:

hash() [3/4]

sha256 fc::sha256::hash ( const string & s )

static

Definition at line 50 of file sha256.cpp.

                                         {
      return hash( s.c_str(), s.size() );
    }

Here is the call graph for this function:

hash() [4/4]

template<typename T >

static sha256 fc::sha256::hash ( const T & t )

inlinestatic

Definition at line 30 of file sha256.hpp.

    { 
      sha256::encoder e; 
      fc::raw::pack(e,t);
      return e.result(); 
    } 

Here is the call graph for this function:

inverse_approx_log_32_double()

double fc::sha256::inverse_approx_log_32_double ( uint32_t x )

static

Definition at line 163 of file sha256.cpp.

   {
      uint8_t nzbits = uint8_t( x >> 0x18 );
      if( nzbits == 0 )
         return 0.0;
      uint32_t b = 1 << 0x18;
      uint32_t y = (x & (b-1)) | b;
      return std::ldexp( y, int( nzbits ) - 0x18 );
   }

operator string()

fc::sha256::operator string

(

)

const

Definition at line 29 of file sha256.cpp.

{ return  str(); }

pop_count()

uint32_t fc::sha256::pop_count ( ) const

inline

Definition at line 73 of file sha256.hpp.

    {
       return (uint32_t)(__builtin_popcountll(_hash[0]) +
                         __builtin_popcountll(_hash[1]) +
                         __builtin_popcountll(_hash[2]) +
                         __builtin_popcountll(_hash[3])); 
    }

set_to_inverse_approx_log_32()

void fc::sha256::set_to_inverse_approx_log_32

(

uint32_t

x

)

Definition at line 136 of file sha256.cpp.

   {
      uint8_t nzbits = uint8_t( x >> 0x18 );
      _hash[0] = 0;
      _hash[1] = 0;
      _hash[2] = 0;
      _hash[3] = 0;
      if( nzbits == 0 )
         return;
      uint8_t x0 = uint8_t((x        ) & 0xFF);
      uint8_t x1 = uint8_t((x >> 0x08) & 0xFF);
      uint8_t x2 = uint8_t((x >> 0x10) & 0xFF);
      uint8_t* my_bytes = (uint8_t*) data();
      my_bytes[0x1F] = x0;
      my_bytes[0x1E] = x1;
      my_bytes[0x1D] = x2;
      my_bytes[0x1C] = 1;
 
      if( nzbits <= 0x18 )
      {
         (*this) = (*this) >> (0x18 - nzbits);
      }
      else
         (*this) = (*this) << (nzbits - 0x18);
      return;
   }

Here is the call graph for this function:

str()

string fc::sha256::str

(

)

const

Definition at line 26 of file sha256.cpp.

                            {
      return fc::to_hex( (char*)_hash, sizeof(_hash) );
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator!=

bool operator!= ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 98 of file sha256.cpp.

                                                            {
       return !(h1 == h2);
    }

operator<

bool operator< ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 95 of file sha256.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) < 0;
    }

operator<< [1/2]

sha256 operator<< ( const sha256 & h1, uint32_t i )

friend

Definition at line 71 of file sha256.cpp.

                                                        {
      sha256 result;
      fc::detail::shift_l( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator<< [2/2]

template<typename T >

T & operator<< ( T & ds, const sha256 & ep )

friend

Definition at line 54 of file sha256.hpp.

                                                           {
      ds.write( ep.data(), sizeof(ep) );
      return ds;
    }

operator==

bool operator== ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 101 of file sha256.cpp.

                                                            {
       // idea to not use memcmp, from:
       //   https://lemire.me/blog/2018/08/22/avoid-lexicographical-comparisons-when-testing-for-string-equality/
       return
             h1._hash[0] == h2._hash[0] &&
             h1._hash[1] == h2._hash[1] &&
             h1._hash[2] == h2._hash[2] &&
             h1._hash[3] == h2._hash[3];
    }

operator>

bool operator> ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 92 of file sha256.cpp.

                                                           {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) > 0;
    }

operator>=

bool operator>= ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 89 of file sha256.cpp.

                                                            {
      return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) >= 0;
    }

operator>> [1/2]

sha256 operator>> ( const sha256 & h1, uint32_t i )

friend

Definition at line 76 of file sha256.cpp.

                                                        {
      sha256 result;
      fc::detail::shift_r( h1.data(), result.data(), result.data_size(), i );
      return result;
    }

operator>> [2/2]

template<typename T >

T & operator>> ( T & ds, sha256 & ep )

friend

Definition at line 60 of file sha256.hpp.

                                                     {
      ds.read( ep.data(), sizeof(ep) );
      return ds;
    }

operator^

sha256 operator^ ( const sha256 & h1, const sha256 & h2 )

friend

Definition at line 81 of file sha256.cpp.

                                                             {
      sha256 result;
      result._hash[0] = h1._hash[0] ^ h2._hash[0];
      result._hash[1] = h1._hash[1] ^ h2._hash[1];
      result._hash[2] = h1._hash[2] ^ h2._hash[2];
      result._hash[3] = h1._hash[3] ^ h2._hash[3];
      return result;
    }

Member Data Documentation

_hash

uint64_t fc::sha256::_hash[4]

Definition at line 100 of file sha256.hpp.

---

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

• libraries/fc/include/fc/crypto/sha256.hpp
• libraries/fc/src/crypto/sha256.cpp