Mohamed Mahmoud Elbaba

Level 1

Hash Family and How Hash Functions Work

Overview of Hash Functions

Hash functions are a critical part of computer science, cryptography, and data
integrity. They are algorithms that take an input (or 'message') and return a fixed-
size string of bytes. This output is typically a digest that appears random and is
unique to the input.

Characteristics of Hash Functions

1. Deterministic: A specific input will always produce the same output hash.
2. Fixed Length Output: Regardless of input size, the output is always the same
length (e.g., 256 bits for SHA-256).
3. Pre-image Resistance: It should be computationally infeasible to reverse-
engineer the original input from its hash.
4. Small Changes in Input Produce Drastically Different Outputs: A minor change
in the input should result in a vastly different hash.
5. Collision Resistance: It should be infeasible to find two different inputs that
produce the same hash output.
Common Hash Functions and Families
1. MD5 (Message Digest Algorithm 5): Produces a 128-bit hash. It is now
considered broken and unsuitable for further use due to vulnerabilities.
2. SHA-1 (Secure Hash Algorithm 1): Produces a 160-bit hash. Also considered
broken and deprecated due to vulnerabilities.
3. SHA-2 Family: Includes SHA-224, SHA-256, SHA-384, and SHA-512. These are
widely used and considered secure.
4. SHA-3 Family: The latest member of the Secure Hash Algorithm family,
designed to provide an alternative to SHA-2 with different internal structures.

How Hash Functions Work

Hash functions process data through a series of steps to produce a hash value.
Here's a general overview of the process:
1. Initialization: Set up initial parameters, constants, and variables.
2. Preprocessing: The input is padded to ensure its length is a multiple of a certain
block size. Padding typically involves adding a single '1' bit followed by a series of
'0' bits and ending with a length value of the original input.
3. Processing: The input data is divided into fixed-size blocks, and each block is
processed iteratively through a series of mathematical transformations. These
transformations involve bitwise operations, modular additions, and other
arithmetic operations.
4. Finalization: After all blocks are processed, the final hash value is produced.
 #include <iostream>

#include <vector>

Example: SHA-512 #include <cstdint>

#include <cstring>
SHA-512 follows a similar process to SHA-256 but works
class SHA512 {
with 64-bit words and produces a 512-bit hash.
public:

1. Initialization: Define constants and initial hash SHA512() { reset(); }

values derived from the first 64 bits of the fractional void update(const uint8_t* data, size_t length);

parts of the square roots of the first 8 prime numbers. void finalize(uint8_t hash[64]);

void reset();
2. Preprocessing: Pad the input so that its length is
private:
congruent to 896 modulo 1024. Append the original
void transform(const uint8_t* data);
length of the message as a 128-bit integer.
static const uint64_t k[80];

3. Processing: Divide the input into 1024-bit blocks. For uint64_t state[8];

each block: std::vector<uint8_t> buffer;

uint64_t bit_length;
• Expand the block into 80 words of 64 bits each.
};

• Initialize working variables to the current hash value. // Constants

const uint64_t SHA512::k[80] = {

• Perform 80 rounds of processing using a specific
// Initialize the SHA-512 constants here
sequence of bitwise operations and modular additions.
};

• Update the hash values with the results of the // Initial hash values

rounds. const uint64_t initial_state[8] = {

0x6a09e667f3bcc908, 0xbb67ae8584caa73b,
4. Finalization: Concatenate the hash values to
0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
produce the final 512-bit hash.
0x510e527fade682d1, 0x9b05688c2b3e6c1f,

0x1f83d9abfb41bd6b, 0x5be0cd19137e2179

};

// Other methods omitted for brevity...

// You need to implement update, transform, and finalize methods

int main() {

SHA512 sha512;

std::string input = "Hello, World!";

sha512.update(reinterpret_cast<const uint8_t*>(input.c_str()), input.size());

uint8_t hash[64];

sha512.finalize(hash);

// Output the hash

for (int i = 0; i < 64; ++i) {

printf("%02x", hash[i]);

std::cout << std::endl;

return 0;

}
 #include <iostream>

Example: SHA-256 #include <vector>

#include <cstdint>
SHA-256 is a member of the SHA-2 family, producing a #include <cstring>
256-bit hash. Here's a detailed look at its processing class SHA256 {
steps: public:

1. Initialization: Define constants and initial hash SHA256() { reset(); }

values. These are derived from the first 32 bits of the void update(const uint8_t* data, size_t length);

fractional parts of the square roots of the first 8 prime void finalize(uint8_t hash[32]);

numbers. void reset();

private:
2. Preprocessing: Pad the input so that its length is void transform(const uint8_t* data);
congruent to 448 modulo 512. Append the original static const uint32_t k[64];
length of the message as a 64-bit integer. uint32_t state[8];

3. Processing: Divide the input into 512-bit blocks. For std::vector<uint8_t> buffer;

each block: uint64_t bit_length;

};
• Expand the block into 64 words of 32 bits each. // Constants

• Initialize working variables to the current hash value. const uint32_t SHA256::k[64] = {

// ... (Initialize the SHA-256 constants here)

• Perform 64 rounds of processing using a specific };
sequence of bitwise operations and modular additions. // Initial hash values

• Update the hash values with the results of the const uint32_t initial_state[8] = {

rounds. 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,

0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19

4. Finalization: Concatenate the hash values to };
produce the final 256-bit hash. // Other methods omitted for brevity...

// You need to implement update, transform, and finalize methods

int main() {

SHA256 sha256;

std::string input = "Hello, World!";

sha256.update(reinterpret_cast<const uint8_t*>(input.c_str()), input.size());

uint8_t hash[32];

sha256.finalize(hash);

// Output the hash

for (int i = 0; i < 32; ++i) {

printf("%02x", hash[i]);

std::cout << std::endl;

return 0;