sha256實現程式碼（C++模板類）
阿新 • • 發佈：2019-02-06
目前在網上找到的比較高效穩定的一個生成sha256的程式碼，只包含標頭檔案就可以了，簡單易用，同時方便學習
可以從stl的各種容器，std::string，字串，檔案流等生成sha256，經過測試比較穩定：
標頭檔案picosha2.h
#ifndef PICOSHA2_H #define PICOSHA2_H // picosha2:20140213 #ifndef PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR #define PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR \ 1048576 //=1024*1024: default is 1MB memory #endif #include <algorithm> #include <cassert> #include <iterator> #include <sstream> #include <vector> namespace picosha2 { typedef unsigned long word_t; typedef unsigned char byte_t; static const size_t k_digest_size = 32; namespace detail { inline byte_t mask_8bit(byte_t x) { return x & 0xff; } inline word_t mask_32bit(word_t x) { return x & 0xffffffff; } const word_t add_constant[64] = { 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 }; const word_t initial_message_digest[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 }; inline word_t ch(word_t x, word_t y, word_t z) { return (x & y) ^ ((~x) & z); } inline word_t maj(word_t x, word_t y, word_t z) { return (x & y) ^ (x & z) ^ (y & z); } inline word_t rotr(word_t x, std::size_t n) { assert(n < 32); return mask_32bit((x >> n) | (x << (32 - n))); } inline word_t bsig0(word_t x) { return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22); } inline word_t bsig1(word_t x) { return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25); } inline word_t shr(word_t x, std::size_t n) { assert(n < 32); return x >> n; } inline word_t ssig0(word_t x) { return rotr(x, 7) ^ rotr(x, 18) ^ shr(x, 3); } inline word_t ssig1(word_t x) { return rotr(x, 17) ^ rotr(x, 19) ^ shr(x, 10); } template <typename RaIter1, typename RaIter2> void hash256_block(RaIter1 message_digest, RaIter2 first, RaIter2 last) { assert(first + 64 == last); static_cast<void>(last); // for avoiding unused-variable warning word_t w[64]; std::fill(w, w + 64, 0); for (std::size_t i = 0; i < 16; ++i) { w[i] = (static_cast<word_t>(mask_8bit(*(first + i * 4))) << 24) | (static_cast<word_t>(mask_8bit(*(first + i * 4 + 1))) << 16) | (static_cast<word_t>(mask_8bit(*(first + i * 4 + 2))) << 8) | (static_cast<word_t>(mask_8bit(*(first + i * 4 + 3)))); } for (std::size_t i = 16; i < 64; ++i) { w[i] = mask_32bit(ssig1(w[i - 2]) + w[i - 7] + ssig0(w[i - 15]) + w[i - 16]); } word_t a = *message_digest; word_t b = *(message_digest + 1); word_t c = *(message_digest + 2); word_t d = *(message_digest + 3); word_t e = *(message_digest + 4); word_t f = *(message_digest + 5); word_t g = *(message_digest + 6); word_t h = *(message_digest + 7); for (std::size_t i = 0; i < 64; ++i) { word_t temp1 = h + bsig1(e) + ch(e, f, g) + add_constant[i] + w[i]; word_t temp2 = bsig0(a) + maj(a, b, c); h = g; g = f; f = e; e = mask_32bit(d + temp1); d = c; c = b; b = a; a = mask_32bit(temp1 + temp2); } *message_digest += a; *(message_digest + 1) += b; *(message_digest + 2) += c; *(message_digest + 3) += d; *(message_digest + 4) += e; *(message_digest + 5) += f; *(message_digest + 6) += g; *(message_digest + 7) += h; for (std::size_t i = 0; i < 8; ++i) { *(message_digest + i) = mask_32bit(*(message_digest + i)); } } } // namespace detail template <typename InIter> void output_hex(InIter first, InIter last, std::ostream& os) { os.setf(std::ios::hex, std::ios::basefield); while (first != last) { os.width(2); os.fill('0'); os << static_cast<unsigned int>(*first); ++first; } os.setf(std::ios::dec, std::ios::basefield); } template <typename InIter> void bytes_to_hex_string(InIter first, InIter last, std::string& hex_str) { std::ostringstream oss; output_hex(first, last, oss); hex_str.assign(oss.str()); } template <typename InContainer> void bytes_to_hex_string(const InContainer& bytes, std::string& hex_str) { bytes_to_hex_string(bytes.begin(), bytes.end(), hex_str); } template <typename InIter> std::string bytes_to_hex_string(InIter first, InIter last) { std::string hex_str; bytes_to_hex_string(first, last, hex_str); return hex_str; } template <typename InContainer> std::string bytes_to_hex_string(const InContainer& bytes) { std::string hex_str; bytes_to_hex_string(bytes, hex_str); return hex_str; } class hash256_one_by_one { public: hash256_one_by_one() { init(); } void init() { buffer_.clear(); std::fill(data_length_digits_, data_length_digits_ + 4, 0); std::copy(detail::initial_message_digest, detail::initial_message_digest + 8, h_); } template <typename RaIter> void process(RaIter first, RaIter last) { add_to_data_length(std::distance(first, last)); std::copy(first, last, std::back_inserter(buffer_)); std::size_t i = 0; for (; i + 64 <= buffer_.size(); i += 64) { detail::hash256_block(h_, buffer_.begin() + i, buffer_.begin() + i + 64); } buffer_.erase(buffer_.begin(), buffer_.begin() + i); } void finish() { byte_t temp[64]; std::fill(temp, temp + 64, 0); std::size_t remains = buffer_.size(); std::copy(buffer_.begin(), buffer_.end(), temp); temp[remains] = 0x80; if (remains > 55) { std::fill(temp + remains + 1, temp + 64, 0); detail::hash256_block(h_, temp, temp + 64); std::fill(temp, temp + 64 - 4, 0); } else { std::fill(temp + remains + 1, temp + 64 - 4, 0); } write_data_bit_length(&(temp[56])); detail::hash256_block(h_, temp, temp + 64); } template <typename OutIter> void get_hash_bytes(OutIter first, OutIter last) const { for (const word_t* iter = h_; iter != h_ + 8; ++iter) { for (std::size_t i = 0; i < 4 && first != last; ++i) { *(first++) = detail::mask_8bit( static_cast<byte_t>((*iter >> (24 - 8 * i)))); } } } private: void add_to_data_length(word_t n) { word_t carry = 0; data_length_digits_[0] += n; for (std::size_t i = 0; i < 4; ++i) { data_length_digits_[i] += carry; if (data_length_digits_[i] >= 65536u) { carry = data_length_digits_[i] >> 16; data_length_digits_[i] &= 65535u; } else { break; } } } void write_data_bit_length(byte_t* begin) { word_t data_bit_length_digits[4]; std::copy(data_length_digits_, data_length_digits_ + 4, data_bit_length_digits); // convert byte length to bit length (multiply 8 or shift 3 times left) word_t carry = 0; for (std::size_t i = 0; i < 4; ++i) { word_t before_val = data_bit_length_digits[i]; data_bit_length_digits[i] <<= 3; data_bit_length_digits[i] |= carry; data_bit_length_digits[i] &= 65535u; carry = (before_val >> (16 - 3)) & 65535u; } // write data_bit_length for (int i = 3; i >= 0; --i) { (*begin++) = static_cast<byte_t>(data_bit_length_digits[i] >> 8); (*begin++) = static_cast<byte_t>(data_bit_length_digits[i]); } } std::vector<byte_t> buffer_; word_t data_length_digits_[4]; // as 64bit integer (16bit x 4 integer) word_t h_[8]; }; inline void get_hash_hex_string(const hash256_one_by_one& hasher, std::string& hex_str) { byte_t hash[k_digest_size]; hasher.get_hash_bytes(hash, hash + k_digest_size); return bytes_to_hex_string(hash, hash + k_digest_size, hex_str); } inline std::string get_hash_hex_string(const hash256_one_by_one& hasher) { std::string hex_str; get_hash_hex_string(hasher, hex_str); return hex_str; } namespace impl { template <typename RaIter, typename OutIter> void hash256_impl(RaIter first, RaIter last, OutIter first2, OutIter last2, int, std::random_access_iterator_tag) { hash256_one_by_one hasher; // hasher.init(); hasher.process(first, last); hasher.finish(); hasher.get_hash_bytes(first2, last2); } template <typename InputIter, typename OutIter> void hash256_impl(InputIter first, InputIter last, OutIter first2, OutIter last2, int buffer_size, std::input_iterator_tag) { std::vector<byte_t> buffer(buffer_size); hash256_one_by_one hasher; // hasher.init(); while (first != last) { int size = buffer_size; for (int i = 0; i != buffer_size; ++i, ++first) { if (first == last) { size = i; break; } buffer[i] = *first; } hasher.process(buffer.begin(), buffer.begin() + size); } hasher.finish(); hasher.get_hash_bytes(first2, last2); } } template <typename InIter, typename OutIter> void hash256(InIter first, InIter last, OutIter first2, OutIter last2, int buffer_size = PICOSHA2_BUFFER_SIZE_FOR_INPUT_ITERATOR) { picosha2::impl::hash256_impl( first, last, first2, last2, buffer_size, typename std::iterator_traits<InIter>::iterator_category()); } template <typename InIter, typename OutContainer> void hash256(InIter first, InIter last, OutContainer& dst) { hash256(first, last, dst.begin(), dst.end()); } template <typename InContainer, typename OutIter> void hash256(const InContainer& src, OutIter first, OutIter last) { hash256(src.begin(), src.end(), first, last); } template <typename InContainer, typename OutContainer> void hash256(const InContainer& src, OutContainer& dst) { hash256(src.begin(), src.end(), dst.begin(), dst.end()); } template <typename InIter> void hash256_hex_string(InIter first, InIter last, std::string& hex_str) { byte_t hashed[k_digest_size]; hash256(first, last, hashed, hashed + k_digest_size); std::ostringstream oss; output_hex(hashed, hashed + k_digest_size, oss); hex_str.assign(oss.str()); } template <typename InIter> std::string hash256_hex_string(InIter first, InIter last) { std::string hex_str; hash256_hex_string(first, last, hex_str); return hex_str; } inline void hash256_hex_string(const std::string& src, std::string& hex_str) { hash256_hex_string(src.begin(), src.end(), hex_str); } template <typename InContainer> void hash256_hex_string(const InContainer& src, std::string& hex_str) { hash256_hex_string(src.begin(), src.end(), hex_str); } template <typename InContainer> std::string hash256_hex_string(const InContainer& src) { return hash256_hex_string(src.begin(), src.end()); } } // namespace picosha2 #endif // PICOSHA2_H
使用用例main.cpp：
#include <iostream> #include <fstream> #include "picosha2.h" // 從string生成 void from_string() { std::string src_str = "Hello"; std::string hash_hex_str; std::vector<unsigned char> hash(picosha2::k_digest_size); picosha2::hash256(src_str.begin(), src_str.end(), hash.begin(), hash.end()); hash_hex_str = picosha2::bytes_to_hex_string(hash.begin(), hash.end()); std::cout << hash_hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" picosha2::hash256_hex_string(src_str, hash_hex_str); std::cout << hash_hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" hash_hex_str = picosha2::hash256_hex_string(src_str); std::cout << hash_hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" src_str = "Hello!";//add '!' hash_hex_str = picosha2::hash256_hex_string(src_str.begin(), src_str.end()); std::cout << hash_hex_str << std::endl; //this output is "334d016f755cd6dc58c53a86e183882f8ec14f52fb05345887c8a5edd42c87b7" } //從位元組陣列讀取 void from_bytes() { std::vector<unsigned char> src_vect(5, '\0'); src_vect.at(0) = 'H'; src_vect.at(1) = 'e'; src_vect.at(2) = 'l'; src_vect.at(3) = 'l'; src_vect.at(4) = 'o'; std::string hash_hex_str; picosha2::hash256_hex_string(src_vect, hash_hex_str); std::cout << hash_hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" std::vector<unsigned char> _src_vect(picosha2::k_digest_size, '\0'); _src_vect.at(0) = 'H'; _src_vect.at(1) = 'e'; _src_vect.at(2) = 'l'; _src_vect.at(3) = 'l'; _src_vect.at(4) = 'o'; hash_hex_str = picosha2::hash256_hex_string(_src_vect); std::cout << hash_hex_str << std::endl; //this output is "cd4895ecd6438e664b91e74f0e632438cd092e27da585f77854e5c28239d2f76" unsigned char src_c_array[5] = { 'H','e','l','l','o' }; picosha2::hash256_hex_string(src_c_array, src_c_array + 5, hash_hex_str); std::cout << hash_hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" unsigned char _src_c_array[picosha2::k_digest_size] = { 'H','e','l','l','o' }; hash_hex_str = picosha2::hash256_hex_string(_src_c_array, _src_c_array + picosha2::k_digest_size); std::cout << hash_hex_str << std::endl; //this output is "cd4895ecd6438e664b91e74f0e632438cd092e27da585f77854e5c28239d2f76" } //從檔案讀取 void from_file() { std::ifstream ifs; ifs.open("file.txt", std::ios::binary); //file data is "Hello" std::vector<unsigned char> hash(picosha2::k_digest_size); picosha2::hash256(std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>(), hash.begin(), hash.end()); std::string hex_str = picosha2::bytes_to_hex_string(hash.begin(), hash.end()); std::cout << hex_str << std::endl; //this output is "185f8db32271fe25f561a6fc938b2e264306ec304eda518007d1764826381969" } //從標準輸入讀取 void from_input() { std::cout << "Input freely. To get hash, input \"hash!\". " << std::endl; picosha2::hash256_one_by_one hasher; while (true) { hasher.init(); //reset hasher state while (true) { std::string line; std::getline(std::cin, line); if (line == "hash!") { break; } hasher.process(line.begin(), line.end()); } hasher.finish(); std::string hex_str; picosha2::get_hash_hex_string(hasher, hex_str); std::cout << hex_str << std::endl; } } int main(int argc, char* argv[]) { from_string(); from_bytes(); from_file(); from_input(); return 0; }
程式碼來自github：
https://github.com/okdshin/PicoSHA2