OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: suggested changes

Browse Source
This commit is contained in:
Md. Anisul Haque 2023-05-24 23:09:11 +05:30
parent b9e3972267
commit 792335faba
No known key found for this signature in database
GPG Key ID: C3A12CD6335595D2
1 changed files with 61 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
hashing/sha256.cpp
View File

@ -24,6 +24,18 @@
* @brief Hashing algorithms * @brief Hashing algorithms
*/ */
namespace hashing { namespace hashing {
class Hash {
// Initialize array of hash values with first 32 bits of the fractional
// parts of the square roots of the first 8 primes 2..19
std::array<uint32_t, 8> hash = {0x6A09E667, 0xBB67AE85, 0x3C6EF372,
0xA54FF53A, 0x510E527F, 0x9B05688C,
0x1F83D9AB, 0x5BE0CD19};
public:
void update(const std::array<uint32_t, 64> &blocks);
std::string to_string();
};
/** /**
* @namespace SHA-256 * @namespace SHA-256
* @brief Functions for the [SHA-256](https://en.wikipedia.org/wiki/SHA-2) * @brief Functions for the [SHA-256](https://en.wikipedia.org/wiki/SHA-2)
@ -53,7 +65,7 @@ uint8_t extract_byte(const T in_value, const std::size_t byte_num) {
if (sizeof(in_value) <= byte_num) { if (sizeof(in_value) <= byte_num) {
throw std::out_of_range("Byte at index byte_num does not exist"); throw std::out_of_range("Byte at index byte_num does not exist");
} }
return ((in_value >> (byte_num * 8)) & 0xFF); return (in_value >> (byte_num * 8)) & 0xFF;
} }
/** /**
@ -94,44 +106,63 @@ uint32_t right_rotate(uint32_t n, size_t rotate) {
/** /**
* @brief Creates the message schedule array * @brief Creates the message schedule array
* @param input Input string * @param input Input string
* @param i Position of the first bit of the chunk * @param byte_num Position of the first byte of the chunk
* @return std::array<uint32_t, 64> Message schedule array * @return std::array<uint32_t, 64> Message schedule array
*/ */
std::array<uint32_t, 64> create_message_schedule_array(const std::string &input, std::array<uint32_t, 64> create_message_schedule_array(const std::string &input,
const size_t i) { const size_t byte_num) {
std::array<uint32_t, 64> blocks{}; std::array<uint32_t, 64> blocks{};
// Copy chunk into first 16 words of the message schedule array // Copy chunk into first 16 words of the message schedule array
for (size_t j = 0; j < 16; ++j) { for (size_t block_num = 0; block_num < 16; ++block_num) {
blocks[j] = blocks[block_num] =
(static_cast<uint8_t>(get_char(input, i + j * 4)) << 24) | (static_cast<uint8_t>(get_char(input, byte_num + block_num * 4))
(static_cast<uint8_t>(get_char(input, i + j * 4 + 1)) << 16) | << 24) |
(static_cast<uint8_t>(get_char(input, i + j * 4 + 2)) << 8) | (static_cast<uint8_t>(get_char(input, byte_num + block_num * 4 + 1))
static_cast<uint8_t>(get_char(input, i + j * 4 + 3)); << 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 // Extend the first 16 words into remaining 48 words of the message schedule
// array // array
for (size_t j = 16; j < 64; ++j) { for (size_t block_num = 16; block_num < 64; ++block_num) {
const auto s0 = right_rotate(blocks[j - 15], 7) ^ const auto s0 = right_rotate(blocks[block_num - 15], 7) ^
right_rotate(blocks[j - 15], 18) ^ right_rotate(blocks[block_num - 15], 18) ^
(blocks[j - 15] >> 3); (blocks[block_num - 15] >> 3);
const auto s1 = right_rotate(blocks[j - 2], 17) ^ const auto s1 = right_rotate(blocks[block_num - 2], 17) ^
right_rotate(blocks[j - 2], 19) ^ (blocks[j - 2] >> 10); right_rotate(blocks[block_num - 2], 19) ^
blocks[j] = blocks[j - 16] + s0 + blocks[j - 7] + s1; (blocks[block_num - 2] >> 10);
blocks[block_num] =
blocks[block_num - 16] + s0 + blocks[block_num - 7] + s1;
} }
return blocks; return blocks;
} }
/** /**
* @brief Modifies the hash array * @brief Computes the final hash value
* @param hash Hash array to be modified * @param input Input string
* @return std::string The final hash value
*/
std::string sha256(const std::string &input) {
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();
}
} // namespace sha256
/**
* @brief Updates the hash array
* @param blocks Message schedule array * @param blocks Message schedule array
* @return void * @return void
*/ */
void modify_hash(std::array<uint32_t, 8> &hash, void Hash::update(const std::array<uint32_t, 64> &blocks) {
const std::array<uint32_t, 64> &blocks) {
// Initialize array of round constants with first 32 bits of the fractional // Initialize array of round constants with first 32 bits of the fractional
// parts of the cube roots of the first 64 primes 2..311 // parts of the cube roots of the first 64 primes 2..311
const std::array<uint32_t, 64> k = { const std::array<uint32_t, 64> k = {
@ -158,13 +189,15 @@ void modify_hash(std::array<uint32_t, 8> &hash,
auto h = hash[7]; auto h = hash[7];
// Compression function main loop // Compression function main loop
for (size_t j = 0; j < 64; ++j) { for (size_t block_num = 0; block_num < 64; ++block_num) {
const auto s1 = const auto s1 = sha256::right_rotate(e, 6) ^
right_rotate(e, 6) ^ right_rotate(e, 11) ^ right_rotate(e, 25); sha256::right_rotate(e, 11) ^
sha256::right_rotate(e, 25);
const auto ch = (e & f) ^ (~e & g); const auto ch = (e & f) ^ (~e & g);
const auto temp1 = h + s1 + ch + k[j] + blocks[j]; const auto temp1 = h + s1 + ch + k[block_num] + blocks[block_num];
const auto s0 = const auto s0 = sha256::right_rotate(a, 2) ^
right_rotate(a, 2) ^ right_rotate(a, 13) ^ right_rotate(a, 22); sha256::right_rotate(a, 13) ^
sha256::right_rotate(a, 22);
const auto maj = (a & b) ^ (a & c) ^ (b & c); const auto maj = (a & b) ^ (a & c) ^ (b & c);
const auto temp2 = s0 + maj; const auto temp2 = s0 + maj;
@ -189,51 +222,17 @@ void modify_hash(std::array<uint32_t, 8> &hash,
hash[7] += h; hash[7] += h;
} }
/**
* @brief Computes the final hash array
* @param input Input string
* @return std::array<uint32_t, 8> The final hash array
*/
std::array<uint32_t, 8> compute_hash(const std::string &input) {
// Initialize array of hash values with first 32 bits of the fractional
// parts of the square roots of the first 8 primes 2..19
std::array<uint32_t, 8> hash = {0x6A09E667, 0xBB67AE85, 0x3C6EF372,
0xA54FF53A, 0x510E527F, 0x9B05688C,
0x1F83D9AB, 0x5BE0CD19};
// Process message in successive 512-bit (64-byte) chunks
for (size_t i = 0; i < compute_padded_size(input.length()); i += 64) {
modify_hash(hash, create_message_schedule_array(input, i));
}
return hash;
}
/** /**
* @brief Convert the hash to a hexadecimal string * @brief Convert the hash to a hexadecimal string
* @param hash Hash array
* @return std::string Final hash value * @return std::string Final hash value
*/ */
std::string hash_to_string(const std::array<uint32_t, 8> &hash) { std::string Hash::to_string() {
std::stringstream ss; std::stringstream ss;
for (size_t i = 0; i < 8; ++i) { for (size_t i = 0; i < 8; ++i) {
for (size_t j = 0; j < 4; ++j) { ss << std::hex << std::setfill('0') << std::setw(8) << hash[i];
const uint32_t byte = extract_byte<uint32_t>(hash[i], 3 - j);
ss << std::hex << std::setfill('0') << std::setw(2) << byte;
}
} }
return ss.str(); return ss.str();
} }
/**
* @brief The SHA-256 algorithm
* @param input The input string to hash
* @return std::string The final hash value
*/
std::string sha256(const std::string &input) {
return hash_to_string(compute_hash(input));
}
} // namespace sha256
} // namespace hashing } // namespace hashing
/** /**