smash::sha256::Context Class Reference

#include <sha256.h>

A SHA256 context.

Definition at line 19 of file sha256.h.

Collaboration diagram for smash::sha256::Context:

Public Member Functions
	Context ()
	Construct a SHA256 context. More...
void	reset ()
	Reset the SHA256 context. More...
void	update (uint8_t const *buffer, size_t buffer_size)
	Add data to the SHA256 context. More...
void	update (const std::string &buffer)
	Add data to the SHA256 context. More...
Hash	finalize ()
	Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash). More...

Private Member Functions
void	transform_function (uint8_t const *buffer)
	Compress 512-bits. More...

Private Attributes
uint64_t	length_
	Length of the SHA256 hash. More...
uint32_t	state_ [8]
	State of the SHA256 hash. More...
size_t	curlen_
	Current length of the SHA256 hash. More...
uint8_t	buf_ [64]
	Buffer of the SHA256 hash. More...

Constructor & Destructor Documentation

Context()

smash::sha256::Context::Context ( )

inline

Construct a SHA256 context.

Definition at line 37 of file sha256.h.

{ reset(); }

Here is the call graph for this function:

Member Function Documentation

transform_function()

void smash::sha256::Context::transform_function ( uint8_t const *  buffer )

private

Compress 512-bits.

Definition at line 95 of file sha256.cc.

                                                      {
  uint32_t S[8];
  uint32_t W[64];
  uint32_t t0;
  uint32_t t1;
  uint32_t t;
  int i;
 
  // Copy state into S
  for (i = 0; i < 8; i++) {
    S[i] = state_[i];
  }
 
  // Copy the state into 512-bits into W[0..15]
  for (i = 0; i < 16; i++) {
    LOAD32H(W[i], buffer + (4 * i));
  }
 
  // Fill W[16..63]
  for (i = 16; i < 64; i++) {
    W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
  }
 
  // Compress
  for (i = 0; i < 64; i++) {
    Sha256Round(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i);
    t = S[7];
    S[7] = S[6];
    S[6] = S[5];
    S[5] = S[4];
    S[4] = S[3];
    S[3] = S[2];
    S[2] = S[1];
    S[1] = S[0];
    S[0] = t;
  }
 
  // Feedback
  for (i = 0; i < 8; i++) {
    state_[i] += S[i];
  }
}

Here is the caller graph for this function:

reset()

void smash::sha256::Context::reset

(

)

Reset the SHA256 context.

Definition at line 140 of file sha256.cc.

                    {
  curlen_ = 0;
  length_ = 0;
  state_[0] = 0x6A09E667UL;
  state_[1] = 0xBB67AE85UL;
  state_[2] = 0x3C6EF372UL;
  state_[3] = 0xA54FF53AUL;
  state_[4] = 0x510E527FUL;
  state_[5] = 0x9B05688CUL;
  state_[6] = 0x1F83D9ABUL;
  state_[7] = 0x5BE0CD19UL;
}

Here is the caller graph for this function:

update() [1/2]

void smash::sha256::Context::update	(	uint8_t const *	buffer,
		size_t	buffer_size
	)

Add data to the SHA256 context.

This will process the data and update the internal state of the context. Keep on calling this function until all the data has been added. Then call finalize to calculate the hash.

Definition at line 153 of file sha256.cc.

                                                              {
  size_t n;
 
  if (curlen_ > sizeof(buf_)) {
    return;
  }
 
  while (buffer_size > 0) {
    if (curlen_ == 0 && buffer_size >= BLOCK_SIZE) {
      transform_function(buffer);
      length_ += BLOCK_SIZE * 8;
      buffer += BLOCK_SIZE;
      buffer_size -= BLOCK_SIZE;
    } else {
      n = MIN(buffer_size, (BLOCK_SIZE - curlen_));
      memcpy(buf_ + curlen_, buffer, n);
      curlen_ += n;
      buffer += n;
      buffer_size -= n;
      if (curlen_ == BLOCK_SIZE) {
        transform_function(buf_);
        length_ += 8 * BLOCK_SIZE;
        curlen_ = 0;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

update() [2/2]

void smash::sha256::Context::update

(

const std::string &

buffer

)

Add data to the SHA256 context.

This will process the data and update the internal state of the context. Keep on calling this function until all the data has been added. Then call finalize to calculate the hash.

Definition at line 181 of file sha256.cc.

                                            {
  update(reinterpret_cast<const uint8_t*>(buffer.c_str()), buffer.size());
}

Here is the call graph for this function:

finalize()

Hash smash::sha256::Context::finalize

(

)

Performs the final calculation of the hash and returns the digest (32 byte buffer containing 256bit hash).

After calling this, reset must be used to reuse the context.

Definition at line 185 of file sha256.cc.

                       {
  Hash digest{{}};
  if (curlen_ >= sizeof(buf_)) {
    return digest;
  }
 
  // Increase the length of the message
  length_ += curlen_ * 8;
 
  // Append the '1' bit
  buf_[curlen_++] = 0x80;
 
  // if the length is currently above 56 bytes we append zeros
  // then compress.  Then we can fall back to padding zeros and length
  // encoding like normal.
  if (curlen_ > 56) {
    while (curlen_ < 64) {
      buf_[curlen_++] = 0;
    }
    transform_function(buf_);
    curlen_ = 0;
  }
 
  // Pad up to 56 bytes of zeroes
  while (curlen_ < 56) {
    buf_[curlen_++] = 0;
  }
 
  // Store length
  STORE64H(length_, buf_ + 56);
  transform_function(buf_);
 
  // Copy output
  for (int i = 0; i < 8; i++) {
    STORE32H(state_[i], digest.data() + (4 * i));
  }
  return digest;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

length_

uint64_t smash::sha256::Context::length_

private

Length of the SHA256 hash.

Definition at line 22 of file sha256.h.

state_

uint32_t smash::sha256::Context::state_[8]

private

State of the SHA256 hash.

Definition at line 24 of file sha256.h.

curlen_

size_t smash::sha256::Context::curlen_

private

Current length of the SHA256 hash.

Definition at line 26 of file sha256.h.

buf_

uint8_t smash::sha256::Context::buf_[64]

private

Buffer of the SHA256 hash.

Definition at line 28 of file sha256.h.

---

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

• src/include/smash/sha256.h
• src/sha256.cc