crypto::SHA256 Class Reference

#include <SHA256.h>

Public Member Functions
	SHA256 ()
	SHA256 (const SHA256 &)=delete
	SHA256 (SHA256 &&)=delete
SHA256 &	operator= (const SHA256 &)=delete
SHA256 &	operator= (SHA256 &&)=delete
void	Update (const void *data, std::size_t size)
void	Update (const char *zString)
template<typename T >
void	Update (const T &data)
std::string	Finalize ()
void	Reset ()

Static Public Attributes
static constexpr std::size_t	HASH_SIZE = 32
static constexpr std::size_t	BLOCK_SIZE = 64

Private Attributes
uint64_t	mBitLength
uint32_t	mState [8]
uint8_t	mBuffer [BLOCK_SIZE]
uint32_t	mBufferLength

Detailed Description

Definition at line 16 of file SHA256.h.

Constructor & Destructor Documentation

SHA256() [1/3]

crypto::SHA256::SHA256

(

)

Definition at line 93 of file SHA256.cpp.

{
   Reset();
}

References Reset().

Here is the call graph for this function:

SHA256() [2/3]

crypto::SHA256::SHA256 ( const SHA256 &  )

delete

SHA256() [3/3]

crypto::SHA256::SHA256 ( SHA256 &&  )

delete

Member Function Documentation

Finalize()

std::string crypto::SHA256::Finalize

(

)

Definition at line 127 of file SHA256.cpp.

{
   uint8_t pad[SHA256::BLOCK_SIZE];
   std::size_t padLength;
 
   // `mBufferLength` is always less than SHA256::BLOCK_SIZE. See `Update`
   // method.
   assert(mBufferLength < SHA256::BLOCK_SIZE);
 
   mBitLength += mBufferLength * 8;
 
   if (mBufferLength < 56)
   {
      mBuffer[mBufferLength++] = 0x80;
      std::memset(mBuffer + mBufferLength, 0, 56 - mBufferLength);
   }
   else
   {
      mBuffer[mBufferLength++] = 0x80;
      std::memset(
         mBuffer + mBufferLength, 0, SHA256::BLOCK_SIZE - mBufferLength);
      sha256_transform(mState, mBuffer);
      std::memset(mBuffer, 0, 56);
   }
 
 
   mBuffer[56] = (mBitLength >> 56) & 0xff;
   mBuffer[57] = (mBitLength >> 48) & 0xff;
   mBuffer[58] = (mBitLength >> 40) & 0xff;
   mBuffer[59] = (mBitLength >> 32) & 0xff;
   mBuffer[60] = (mBitLength >> 24) & 0xff;
   mBuffer[61] = (mBitLength >> 16) & 0xff;
   mBuffer[62] = (mBitLength >> 8) & 0xff;
   mBuffer[63] = (mBitLength >> 0) & 0xff;
 
   sha256_transform(mState, mBuffer);
 
   uint8_t result[SHA256::HASH_SIZE];
 
   for (int i = 0; i < 8; ++i)
   {
      result[i * 4 + 0] = (mState[i] >> 24) & 0xff;
      result[i * 4 + 1] = (mState[i] >> 16) & 0xff;
      result[i * 4 + 2] = (mState[i] >> 8) & 0xff;
      result[i * 4 + 3] = (mState[i] >> 0) & 0xff;
   }
 
   Reset();
 
   // Convert to hex string
   constexpr char hexChars[] = "0123456789ABCDEF";
   std::string resultStr;
   resultStr.resize(HASH_SIZE * 2);
 
   for (int i = 0; i < SHA256::HASH_SIZE; ++i)
   {
      resultStr[i * 2 + 0] = hexChars[(result[i] >> 4) & 0xf];
      resultStr[i * 2 + 1] = hexChars[result[i] & 0xf];
   }
 
   return resultStr;
}

References BLOCK_SIZE, HASH_SIZE, mBitLength, mBuffer, mBufferLength, mState, Reset(), and crypto::anonymous_namespace{SHA256.cpp}::sha256_transform().

Referenced by crypto::sha256().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

SHA256 & crypto::SHA256::operator= ( const SHA256 &  )

delete

operator=() [2/2]

SHA256 & crypto::SHA256::operator= ( SHA256 &&  )

delete

Reset()

void crypto::SHA256::Reset

(

)

Definition at line 190 of file SHA256.cpp.

{
   mBitLength = 0;
 
   mState[0] = 0x6a09e667;
   mState[1] = 0xbb67ae85;
   mState[2] = 0x3c6ef372;
   mState[3] = 0xa54ff53a;
   mState[4] = 0x510e527f;
   mState[5] = 0x9b05688c;
   mState[6] = 0x1f83d9ab;
   mState[7] = 0x5be0cd19;
 
   std::memset(mBuffer, 0, sizeof(mBuffer));
   mBufferLength = 0;
}

References mBitLength, mBuffer, mBufferLength, and mState.

Referenced by Finalize(), and SHA256().

Here is the caller graph for this function:

Update() [1/3]

void crypto::SHA256::Update

(

const char *

zString

)

Definition at line 122 of file SHA256.cpp.

{
   Update(zString, std::strlen(zString));
}

References Update().

Here is the call graph for this function:

Update() [2/3]

template<typename T >

void crypto::SHA256::Update ( const T &  data )

inline

Definition at line 33 of file SHA256.h.

   {
      Update(data.data(), data.size());
   }

Update() [3/3]

void crypto::SHA256::Update	(	const void *	data,
		std::size_t	size
	)

Definition at line 98 of file SHA256.cpp.

{
   const uint8_t* dataPtr = static_cast<const uint8_t*>(data);
 
   while (size > 0)
   {
      std::size_t blockSize =
         std::min<size_t>(size, SHA256::BLOCK_SIZE - mBufferLength);
 
      std::memcpy(mBuffer + mBufferLength, dataPtr, blockSize);
 
      mBufferLength += blockSize;
      dataPtr += blockSize;
      size -= blockSize;
 
      if (mBufferLength == SHA256::BLOCK_SIZE)
      {
         sha256_transform(mState, mBuffer);
         mBitLength += 512;
         mBufferLength = 0;
      }
   }
}

References BLOCK_SIZE, mBitLength, mBuffer, mBufferLength, mState, crypto::anonymous_namespace{SHA256.cpp}::sha256_transform(), and size.

Referenced by crypto::sha256(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BLOCK_SIZE

constexpr std::size_t crypto::SHA256::BLOCK_SIZE = 64

staticconstexpr

Definition at line 20 of file SHA256.h.

Referenced by Finalize(), crypto::anonymous_namespace{SHA256.cpp}::sha256_transform(), and Update().

HASH_SIZE

constexpr std::size_t crypto::SHA256::HASH_SIZE = 32

staticconstexpr

Definition at line 19 of file SHA256.h.

Referenced by Finalize().

mBitLength

uint64_t crypto::SHA256::mBitLength

private

Definition at line 43 of file SHA256.h.

Referenced by Finalize(), Reset(), and Update().

mBuffer

uint8_t crypto::SHA256::mBuffer[BLOCK_SIZE]

private

Definition at line 45 of file SHA256.h.

Referenced by Finalize(), Reset(), and Update().

mBufferLength

uint32_t crypto::SHA256::mBufferLength

private

Definition at line 46 of file SHA256.h.

Referenced by Finalize(), Reset(), and Update().

mState

uint32_t crypto::SHA256::mState[8]

private

Definition at line 44 of file SHA256.h.

Referenced by Finalize(), Reset(), and Update().

---

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

• SHA256.h
• SHA256.cpp