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:

Go to the source code of this file.

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

Namespaces
namespace	hashing
	Used for assert.
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.

Definition in file sha256.cpp.

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

Definition at line 143 of file sha256.cpp.

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

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

Definition at line 195 of file sha256.cpp.

                                                                              {
    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;
}

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

Definition at line 157 of file sha256.cpp.

                                                                 {
    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;
}

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

Definition at line 170 of file sha256.cpp.

                                                     {
    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));
}

main()

int main

(

void

)

Main function.

Returns

0 on exit

Definition at line 326 of file sha256.cpp.

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

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

Definition at line 58 of file sha256.cpp.

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

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

Definition at line 232 of file sha256.cpp.

                                         {
    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();
}

test()

static void test ( )

static

Definition at line 312 of file sha256.cpp.

                   {
    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

Definition at line 248 of file sha256.cpp.

                                       {
    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

Definition at line 254 of file sha256.cpp.

                                {
    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

Definition at line 266 of file sha256.cpp.

                            {
    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

Definition at line 280 of file sha256.cpp.

                                {
    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

Definition at line 286 of file sha256.cpp.

                          {
    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);
    }
}