sha256.cpp File Reference

Simple C++ implementation of the [SHA-256 Hashing Algorithm] (https://en.wikipedia.org/wiki/SHA-2) More...

#include <array>
#include <cassert>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <utility>
#include <vector>

Include dependency graph for sha256.cpp:

Classes
class	hashing::sha256::Hash
	Contains hash array and functions to update it and convert it to a hexadecimal string. More...

Namespaces
namespace	hashing
	Hashing algorithms.
namespace	SHA
	Functions for the SHA-1 algorithm implementation.

Functions
uint32_t	hashing::sha256::right_rotate (uint32_t n, size_t rotate)
	Rotates the bits of a 32-bit unsigned integer.
std::size_t	hashing::sha256::compute_padded_size (const std::size_t input_size)
	Computes size of the padded input.
template<typename T >
uint8_t	hashing::sha256::extract_byte (const T in_value, const std::size_t byte_num)
	Returns the byte at position byte_num in in_value.
char	hashing::sha256::get_char (const std::string &input, std::size_t pos)
	Returns the character at pos after the input is padded.
std::array< uint32_t, 64 >	hashing::sha256::create_message_schedule_array (const std::string &input, const size_t byte_num)
	Creates the message schedule array.
std::string	hashing::sha256::sha256 (const std::string &input)
	Computes the final hash value.
static void	test_compute_padded_size ()
	Self-test implementations.
static void	test_extract_byte ()
static void	test_get_char ()
static void	test_right_rotate ()
static void	test_sha256 ()
static void	test ()
int	main ()
	Main function.

Detailed Description

Simple C++ implementation of the [SHA-256 Hashing Algorithm] (https://en.wikipedia.org/wiki/SHA-2)

Author

Md. Anisul Haque

SHA-2 is a set of cryptographic hash functions that was designed by the NSA and first published in 2001. SHA-256 is a part of the SHA-2 family. SHA-256 is widely used for authenticating software packages and secure password hashing.

Function Documentation

compute_padded_size()

std::size_t hashing::sha256::compute_padded_size

(

const std::size_t

input_size

)

Computes size of the padded input.

Parameters

input

Input string

Returns

size_t Size of the padded input

                                                          {
    if (input_size % 64 < 56) {
        return input_size + 64 - (input_size % 64);
    }
    return input_size + 128 - (input_size % 64);
}

Here is the call graph for this function:

create_message_schedule_array()

std::array< uint32_t, 64 > hashing::sha256::create_message_schedule_array	(	const std::string &	input,
		const size_t	byte_num )

Creates the message schedule array.

Parameters

input	Input string
byte_num	Position of the first byte of the chunk

Returns

std::array<uint32_t, 64> Message schedule array

                                                                              {
    std::array<uint32_t, 64> blocks{};
 
    // Copy chunk into first 16 words of the message schedule array
    for (size_t block_num = 0; block_num < 16; ++block_num) {
        blocks[block_num] =
            (static_cast<uint8_t>(get_char(input, byte_num + block_num * 4))
             << 24) |
            (static_cast<uint8_t>(get_char(input, byte_num + block_num * 4 + 1))
             << 16) |
            (static_cast<uint8_t>(get_char(input, byte_num + block_num * 4 + 2))
             << 8) |
            static_cast<uint8_t>(get_char(input, byte_num + block_num * 4 + 3));
    }
 
    // Extend the first 16 words into remaining 48 words of the message schedule
    // array
    for (size_t block_num = 16; block_num < 64; ++block_num) {
        const auto s0 = right_rotate(blocks[block_num - 15], 7) ^
                        right_rotate(blocks[block_num - 15], 18) ^
                        (blocks[block_num - 15] >> 3);
        const auto s1 = right_rotate(blocks[block_num - 2], 17) ^
                        right_rotate(blocks[block_num - 2], 19) ^
                        (blocks[block_num - 2] >> 10);
        blocks[block_num] =
            blocks[block_num - 16] + s0 + blocks[block_num - 7] + s1;
    }
 
    return blocks;
}

Here is the call graph for this function:

extract_byte()

template<typename T >

uint8_t hashing::sha256::extract_byte	(	const T	in_value,
		const std::size_t	byte_num )

Returns the byte at position byte_num in in_value.

Parameters

in_value	Input value
byte_num	Position of byte to be returned

Returns

uint8_t Byte at position byte_num

                                                                 {
    if (sizeof(in_value) <= byte_num) {
        throw std::out_of_range("Byte at index byte_num does not exist");
    }
    return (in_value >> (byte_num * 8)) & 0xFF;
}

Here is the call graph for this function:

get_char()

char hashing::sha256::get_char	(	const std::string &	input,
		std::size_t	pos )

Returns the character at pos after the input is padded.

Parameters

input	Input string
pos	Position of character to be returned

Returns

char Character at the index pos in the padded string

                                                     {
    const auto input_size = input.length();
    if (pos < input_size) {
        return input[pos];
    }
    if (pos == input_size) {
        return '\x80';
    }
    const auto padded_input_size = compute_padded_size(input_size);
    if (pos < padded_input_size - 8) {
        return '\x00';
    }
    if (padded_input_size <= pos) {
        throw std::out_of_range("pos is out of range");
    }
    return static_cast<char>(
        extract_byte<size_t>(input_size * 8, padded_input_size - pos - 1));
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

           {
    test();  // Run self-test implementations
    return 0;
}

Here is the call graph for this function:

right_rotate()

uint32_t hashing::sha256::right_rotate	(	uint32_t	n,
		size_t	rotate )

Rotates the bits of a 32-bit unsigned integer.

Parameters

n	Integer to rotate
rotate	Number of bits to rotate

Returns

uint32_t The rotated integer

                                                 {
    return (n >> rotate) | (n << (32 - rotate));
}

Here is the call graph for this function:

sha256()

std::string hashing::sha256::sha256

(

const std::string &

input

)

Computes the final hash value.

Parameters

input

Input string

Returns

std::string The final hash value

                                         {
    Hash h;
    // Process message in successive 512-bit (64-byte) chunks
    for (size_t byte_num = 0; byte_num < compute_padded_size(input.length());
         byte_num += 64) {
        h.update(create_message_schedule_array(input, byte_num));
    }
    return h.to_string();
}

Here is the call graph for this function:

test()

static void test ( )

static

                   {
    test_compute_padded_size();
    test_extract_byte();
    test_get_char();
    test_right_rotate();
    test_sha256();
 
    std::cout << "All tests have successfully passed!\n";
}

test_compute_padded_size()

static void test_compute_padded_size ( )

static

Self-test implementations.

Returns

void

                                       {
    assert(hashing::sha256::compute_padded_size(55) == 64);
    assert(hashing::sha256::compute_padded_size(56) == 128);
    assert(hashing::sha256::compute_padded_size(130) == 192);
}

test_extract_byte()

static void test_extract_byte ( )

static

                                {
    assert(hashing::sha256::extract_byte<uint32_t>(512, 0) == 0);
    assert(hashing::sha256::extract_byte<uint32_t>(512, 1) == 2);
    bool exception = false;
    try {
        hashing::sha256::extract_byte<uint32_t>(512, 5);
    } catch (const std::out_of_range &) {
        exception = true;
    }
    assert(exception);
}

test_get_char()

static void test_get_char ( )

static

                            {
    assert(hashing::sha256::get_char("test", 3) == 't');
    assert(hashing::sha256::get_char("test", 4) == '\x80');
    assert(hashing::sha256::get_char("test", 5) == '\x00');
    assert(hashing::sha256::get_char("test", 63) == 32);
    bool exception = false;
    try {
        hashing::sha256::get_char("test", 64);
    } catch (const std::out_of_range &) {
        exception = true;
    }
    assert(exception);
}

test_right_rotate()

static void test_right_rotate ( )

static

                                {
    assert(hashing::sha256::right_rotate(128, 3) == 16);
    assert(hashing::sha256::right_rotate(1, 30) == 4);
    assert(hashing::sha256::right_rotate(6, 30) == 24);
}

test_sha256()

static void test_sha256 ( )

static

                          {
    struct TestCase {
        const std::string input;
        const std::string expected_hash;
        TestCase(std::string input, std::string expected_hash)
            : input(std::move(input)),
              expected_hash(std::move(expected_hash)) {}
    };
    const std::vector<TestCase> test_cases{
        TestCase(
            "",
            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"),
        TestCase(
            "test",
            "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"),
        TestCase(
            "Hello World",
            "a591a6d40bf420404a011733cfb7b190d62c65bf0bcda32b57b277d9ad9f146e"),
        TestCase("Hello World!",
                 "7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9"
                 "069")};
    for (const auto &tc : test_cases) {
        assert(hashing::sha256::sha256(tc.input) == tc.expected_hash);
    }
}