kvazar
/
kevacoin
mirror of https://github.com/kvazar-network/kevacoin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Merge pull request #4977 

cf42c36 Apply clang-format on crypto/* and compat/* (Pieter Wuille)
0.10
Pieter Wuille 10 years ago
parent
4b2b78b9f2 cf42c36e99
commit
c2db599c1f
No known key found for this signature in database
GPG Key ID: 57896D2FF8F0B657
11 changed files with 589 additions and 458 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      src/compat/glibc_sanity.cpp
  2. 7
      src/compat/glibcxx_compat.cpp
  3. 16
      src/compat/glibcxx_sanity.cpp
  4. 55
      src/crypto/common.h
  5. 277
      src/crypto/ripemd160.cpp
  6. 3
      src/crypto/ripemd160.h
  7. 30
      src/crypto/sha1.cpp
  8. 3
      src/crypto/sha1.h
  9. 64
      src/crypto/sha2.cpp
  10. 12
      src/crypto/sha2.h

6
src/compat/glibc_sanity.cpp
Unescape View File

@ -17,7 +17,8 @@ void* memcpy_int(void* a, const void* b, size_t c)
return memcpy(a, b, c); return memcpy(a, b, c);
} }
namespace { namespace
{
// trigger: Use the memcpy_int wrapper which calls our internal memcpy. // trigger: Use the memcpy_int wrapper which calls our internal memcpy.
// A direct call to memcpy may be optimized away by the compiler. // A direct call to memcpy may be optimized away by the compiler.
// test: Fill an array with a sequence of integers. memcpy to a new empty array. // test: Fill an array with a sequence of integers. memcpy to a new empty array.
@ -33,8 +34,7 @@ bool sanity_test_memcpy()
memcpy_int(memcpy_verify, memcpy_test, sizeof(memcpy_test)); memcpy_int(memcpy_verify, memcpy_test, sizeof(memcpy_test));
for (unsigned int i = 0; i != T; ++i) for (unsigned int i = 0; i != T; ++i) {
{
if (memcpy_verify[i] != i) if (memcpy_verify[i] != i)
return false; return false;
} }

7
src/compat/glibcxx_compat.cpp
Unescape View File

@ -11,8 +11,8 @@
#define _GLIBCXX_USE_NOEXCEPT throw() #define _GLIBCXX_USE_NOEXCEPT throw()
#endif #endif
namespace std { namespace std
{
const char* bad_exception::what() const throw() const char* bad_exception::what() const throw()
{ {
return "std::bad_exception"; return "std::bad_exception";
@ -30,8 +30,7 @@ const char* bad_alloc::what() const throw()
namespace __detail namespace __detail
{ {
struct _List_node_base struct _List_node_base {
{
void _M_hook(std::__detail::_List_node_base* const __position) throw() __attribute__((used)) void _M_hook(std::__detail::_List_node_base* const __position) throw() __attribute__((used))
{ {
_M_next = __position; _M_next = __position;

16
src/compat/glibcxx_sanity.cpp
Unescape View File

@ -6,8 +6,8 @@
#include <locale> #include <locale>
#include <stdexcept> #include <stdexcept>
namespace{ namespace
{
// trigger: use ctype<char>::widen to trigger ctype<char>::_M_widen_init(). // trigger: use ctype<char>::widen to trigger ctype<char>::_M_widen_init().
// test: convert a char from narrow to wide and back. Verify that the result // test: convert a char from narrow to wide and back. Verify that the result
// matches the original. // matches the original.
@ -30,8 +30,7 @@ bool sanity_test_list(unsigned int size)
if (test.size() != size) if (test.size() != size)
return false; return false;
while (!test.empty()) while (!test.empty()) {
{
if (test.back() != test.size()) if (test.back() != test.size())
return false; return false;
test.pop_back(); test.pop_back();
@ -47,15 +46,12 @@ bool sanity_test_list(unsigned int size)
bool sanity_test_range_fmt() bool sanity_test_range_fmt()
{ {
std::string test; std::string test;
try try {
{
test.at(1); test.at(1);
} } catch (const std::out_of_range&) {
catch (const std::out_of_range&)
{
return true; return true;
} catch (...) {
} }
catch (...){}
return false; return false;
} }

55
src/crypto/common.h
Unescape View File

@ -13,7 +13,8 @@
#include <endian.h> #include <endian.h>
#endif #endif
uint32_t static inline ReadLE32(const unsigned char *ptr) { uint32_t static inline ReadLE32(const unsigned char* ptr)
{
#if HAVE_DECL_LE32TOH == 1 #if HAVE_DECL_LE32TOH == 1
return le32toh(*((uint32_t*)ptr)); return le32toh(*((uint32_t*)ptr));
#elif !defined(WORDS_BIGENDIAN) #elif !defined(WORDS_BIGENDIAN)
@ -23,8 +24,8 @@ uint32_t static inline ReadLE32(const unsigned char *ptr) {
#endif #endif
} }
uint64_t static inline ReadLE64(const unsigned char *ptr) { uint64_t static inline ReadLE64(const unsigned char* ptr)
{
#if HAVE_DECL_LE64TOH == 1 #if HAVE_DECL_LE64TOH == 1
return le64toh(*((uint64_t*)ptr)); return le64toh(*((uint64_t*)ptr));
#elif !defined(WORDS_BIGENDIAN) #elif !defined(WORDS_BIGENDIAN)
@ -35,28 +36,40 @@ uint64_t static inline ReadLE64(const unsigned char *ptr) {
#endif #endif
} }
void static inline WriteLE32(unsigned char *ptr, uint32_t x) { void static inline WriteLE32(unsigned char* ptr, uint32_t x)
{
#if HAVE_DECL_HTOLE32 == 1 #if HAVE_DECL_HTOLE32 == 1
*((uint32_t*)ptr) = htole32(x); *((uint32_t*)ptr) = htole32(x);
#elif !defined(WORDS_BIGENDIAN) #elif !defined(WORDS_BIGENDIAN)
*((uint32_t*)ptr) = x; *((uint32_t*)ptr) = x;
#else #else
ptr[3] = x >> 24; ptr[2] = x >> 16; ptr[1] = x >> 8; ptr[0] = x; ptr[3] = x >> 24;
ptr[2] = x >> 16;
ptr[1] = x >> 8;
ptr[0] = x;
#endif #endif
} }
void static inline WriteLE64(unsigned char *ptr, uint64_t x) { void static inline WriteLE64(unsigned char* ptr, uint64_t x)
{
#if HAVE_DECL_HTOLE64 == 1 #if HAVE_DECL_HTOLE64 == 1
*((uint64_t*)ptr) = htole64(x); *((uint64_t*)ptr) = htole64(x);
#elif !defined(WORDS_BIGENDIAN) #elif !defined(WORDS_BIGENDIAN)
*((uint64_t*)ptr) = x; *((uint64_t*)ptr) = x;
#else #else
ptr[7] = x >> 56; ptr[6] = x >> 48; ptr[5] = x >> 40; ptr[4] = x >> 32; ptr[7] = x >> 56;
ptr[3] = x >> 24; ptr[2] = x >> 16; ptr[1] = x >> 8; ptr[0] = x; ptr[6] = x >> 48;
ptr[5] = x >> 40;
ptr[4] = x >> 32;
ptr[3] = x >> 24;
ptr[2] = x >> 16;
ptr[1] = x >> 8;
ptr[0] = x;
#endif #endif
} }
uint32_t static inline ReadBE32(const unsigned char *ptr) { uint32_t static inline ReadBE32(const unsigned char* ptr)
{
#if HAVE_DECL_BE32TOH == 1 #if HAVE_DECL_BE32TOH == 1
return be32toh(*((uint32_t*)ptr)); return be32toh(*((uint32_t*)ptr));
#else #else
@ -64,7 +77,8 @@ uint32_t static inline ReadBE32(const unsigned char *ptr) {
#endif #endif
} }
uint64_t static inline ReadBE64(const unsigned char *ptr) { uint64_t static inline ReadBE64(const unsigned char* ptr)
{
#if HAVE_DECL_BE64TOH == 1 #if HAVE_DECL_BE64TOH == 1
return be64toh(*((uint64_t*)ptr)); return be64toh(*((uint64_t*)ptr));
#else #else
@ -73,20 +87,31 @@ uint64_t static inline ReadBE64(const unsigned char *ptr) {
#endif #endif
} }
void static inline WriteBE32(unsigned char *ptr, uint32_t x) { void static inline WriteBE32(unsigned char* ptr, uint32_t x)
{
#if HAVE_DECL_HTOBE32 == 1 #if HAVE_DECL_HTOBE32 == 1
*((uint32_t*)ptr) = htobe32(x); *((uint32_t*)ptr) = htobe32(x);
#else #else
ptr[0] = x >> 24; ptr[1] = x >> 16; ptr[2] = x >> 8; ptr[3] = x; ptr[0] = x >> 24;
ptr[1] = x >> 16;
ptr[2] = x >> 8;
ptr[3] = x;
#endif #endif
} }
void static inline WriteBE64(unsigned char *ptr, uint64_t x) { void static inline WriteBE64(unsigned char* ptr, uint64_t x)
{
#if HAVE_DECL_HTOBE64 == 1 #if HAVE_DECL_HTOBE64 == 1
*((uint64_t*)ptr) = htobe64(x); *((uint64_t*)ptr) = htobe64(x);
#else #else
ptr[0] = x >> 56; ptr[1] = x >> 48; ptr[2] = x >> 40; ptr[3] = x >> 32; ptr[0] = x >> 56;
ptr[4] = x >> 24; ptr[5] = x >> 16; ptr[6] = x >> 8; ptr[7] = x; ptr[1] = x >> 48;
ptr[2] = x >> 40;
ptr[3] = x >> 32;
ptr[4] = x >> 24;
ptr[5] = x >> 16;
ptr[6] = x >> 8;
ptr[7] = x;
#endif #endif
} }

277
src/crypto/ripemd160.cpp
Unescape View File

@ -9,11 +9,11 @@
#include <string.h> #include <string.h>
// Internal implementation code. // Internal implementation code.
namespace { namespace
{
/// Internal RIPEMD-160 implementation. /// Internal RIPEMD-160 implementation.
namespace ripemd160 { namespace ripemd160
{
uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; } uint32_t inline f1(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); } uint32_t inline f2(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; } uint32_t inline f3(uint32_t x, uint32_t y, uint32_t z) { return (x | ~y) ^ z; }
@ -21,7 +21,8 @@ uint32_t inline f4(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~
uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); } uint32_t inline f5(uint32_t x, uint32_t y, uint32_t z) { return x ^ (y | ~z); }
/** Initialize RIPEMD-160 state. */ /** Initialize RIPEMD-160 state. */
void inline Initialize(uint32_t *s) { void inline Initialize(uint32_t* s)
{
s[0] = 0x67452301ul; s[0] = 0x67452301ul;
s[1] = 0xEFCDAB89ul; s[1] = 0xEFCDAB89ul;
s[2] = 0x98BADCFEul; s[2] = 0x98BADCFEul;
@ -31,7 +32,8 @@ void inline Initialize(uint32_t *s) {
uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); } uint32_t inline rol(uint32_t x, int i) { return (x << i) | (x >> (32 - i)); }
void inline Round(uint32_t &a, uint32_t b, uint32_t &c, uint32_t d, uint32_t e, uint32_t f, uint32_t x, uint32_t k, int r) { void inline Round(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t f, uint32_t x, uint32_t k, int r)
{
a = rol(a + f + x + k, r) + e; a = rol(a + f + x + k, r) + e;
c = rol(c, 10); c = rol(c, 10);
} }
@ -49,7 +51,8 @@ void inline R42(uint32_t &a, uint32_t b, uint32_t &c, uint32_t d, uint32_t e, ui
void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); } void inline R52(uint32_t& a, uint32_t b, uint32_t& c, uint32_t d, uint32_t e, uint32_t x, int r) { Round(a, b, c, d, e, f1(b, c, d), x, 0, r); }
/** Perform a RIPEMD-160 transformation, processing a 64-byte chunk. */ /** Perform a RIPEMD-160 transformation, processing a 64-byte chunk. */
void Transform(uint32_t *s, const unsigned char *chunk) { void Transform(uint32_t* s, const unsigned char* chunk)
{
uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4]; uint32_t a1 = s[0], b1 = s[1], c1 = s[2], d1 = s[3], e1 = s[4];
uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1; uint32_t a2 = a1, b2 = b1, c2 = c1, d2 = d1, e2 = e1;
uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12); uint32_t w0 = ReadLE32(chunk + 0), w1 = ReadLE32(chunk + 4), w2 = ReadLE32(chunk + 8), w3 = ReadLE32(chunk + 12);
@ -57,90 +60,170 @@ void Transform(uint32_t *s, const unsigned char *chunk) {
uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44); uint32_t w8 = ReadLE32(chunk + 32), w9 = ReadLE32(chunk + 36), w10 = ReadLE32(chunk + 40), w11 = ReadLE32(chunk + 44);
uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60); uint32_t w12 = ReadLE32(chunk + 48), w13 = ReadLE32(chunk + 52), w14 = ReadLE32(chunk + 56), w15 = ReadLE32(chunk + 60);
R11(a1, b1, c1, d1, e1, w0 , 11); R12(a2, b2, c2, d2, e2, w5 , 8); R11(a1, b1, c1, d1, e1, w0, 11);
R11(e1, a1, b1, c1, d1, w1 , 14); R12(e2, a2, b2, c2, d2, w14, 9); R12(a2, b2, c2, d2, e2, w5, 8);
R11(d1, e1, a1, b1, c1, w2 , 15); R12(d2, e2, a2, b2, c2, w7 , 9); R11(e1, a1, b1, c1, d1, w1, 14);
R11(c1, d1, e1, a1, b1, w3 , 12); R12(c2, d2, e2, a2, b2, w0 , 11); R12(e2, a2, b2, c2, d2, w14, 9);
R11(b1, c1, d1, e1, a1, w4 , 5); R12(b2, c2, d2, e2, a2, w9 , 13); R11(d1, e1, a1, b1, c1, w2, 15);
R11(a1, b1, c1, d1, e1, w5 , 8); R12(a2, b2, c2, d2, e2, w2 , 15); R12(d2, e2, a2, b2, c2, w7, 9);
R11(e1, a1, b1, c1, d1, w6 , 7); R12(e2, a2, b2, c2, d2, w11, 15); R11(c1, d1, e1, a1, b1, w3, 12);
R11(d1, e1, a1, b1, c1, w7 , 9); R12(d2, e2, a2, b2, c2, w4 , 5); R12(c2, d2, e2, a2, b2, w0, 11);
R11(c1, d1, e1, a1, b1, w8 , 11); R12(c2, d2, e2, a2, b2, w13, 7); R11(b1, c1, d1, e1, a1, w4, 5);
R11(b1, c1, d1, e1, a1, w9 , 13); R12(b2, c2, d2, e2, a2, w6 , 7); R12(b2, c2, d2, e2, a2, w9, 13);
R11(a1, b1, c1, d1, e1, w10, 14); R12(a2, b2, c2, d2, e2, w15, 8); R11(a1, b1, c1, d1, e1, w5, 8);
R11(e1, a1, b1, c1, d1, w11, 15); R12(e2, a2, b2, c2, d2, w8 , 11); R12(a2, b2, c2, d2, e2, w2, 15);
R11(d1, e1, a1, b1, c1, w12, 6); R12(d2, e2, a2, b2, c2, w1 , 14); R11(e1, a1, b1, c1, d1, w6, 7);
R11(c1, d1, e1, a1, b1, w13, 7); R12(c2, d2, e2, a2, b2, w10, 14); R12(e2, a2, b2, c2, d2, w11, 15);
R11(b1, c1, d1, e1, a1, w14, 9); R12(b2, c2, d2, e2, a2, w3 , 12); R11(d1, e1, a1, b1, c1, w7, 9);
R11(a1, b1, c1, d1, e1, w15, 8); R12(a2, b2, c2, d2, e2, w12, 6); R12(d2, e2, a2, b2, c2, w4, 5);
R11(c1, d1, e1, a1, b1, w8, 11);
R21(e1, a1, b1, c1, d1, w7 , 7); R22(e2, a2, b2, c2, d2, w6 , 9); R12(c2, d2, e2, a2, b2, w13, 7);
R21(d1, e1, a1, b1, c1, w4 , 6); R22(d2, e2, a2, b2, c2, w11, 13); R11(b1, c1, d1, e1, a1, w9, 13);
R21(c1, d1, e1, a1, b1, w13, 8); R22(c2, d2, e2, a2, b2, w3 , 15); R12(b2, c2, d2, e2, a2, w6, 7);
R21(b1, c1, d1, e1, a1, w1 , 13); R22(b2, c2, d2, e2, a2, w7 , 7); R11(a1, b1, c1, d1, e1, w10, 14);
R21(a1, b1, c1, d1, e1, w10, 11); R22(a2, b2, c2, d2, e2, w0 , 12); R12(a2, b2, c2, d2, e2, w15, 8);
R21(e1, a1, b1, c1, d1, w6 , 9); R22(e2, a2, b2, c2, d2, w13, 8); R11(e1, a1, b1, c1, d1, w11, 15);
R21(d1, e1, a1, b1, c1, w15, 7); R22(d2, e2, a2, b2, c2, w5 , 9); R12(e2, a2, b2, c2, d2, w8, 11);
R21(c1, d1, e1, a1, b1, w3 , 15); R22(c2, d2, e2, a2, b2, w10, 11); R11(d1, e1, a1, b1, c1, w12, 6);
R21(b1, c1, d1, e1, a1, w12, 7); R22(b2, c2, d2, e2, a2, w14, 7); R12(d2, e2, a2, b2, c2, w1, 14);
R21(a1, b1, c1, d1, e1, w0 , 12); R22(a2, b2, c2, d2, e2, w15, 7); R11(c1, d1, e1, a1, b1, w13, 7);
R21(e1, a1, b1, c1, d1, w9 , 15); R22(e2, a2, b2, c2, d2, w8 , 12); R12(c2, d2, e2, a2, b2, w10, 14);
R21(d1, e1, a1, b1, c1, w5 , 9); R22(d2, e2, a2, b2, c2, w12, 7); R11(b1, c1, d1, e1, a1, w14, 9);
R21(c1, d1, e1, a1, b1, w2 , 11); R22(c2, d2, e2, a2, b2, w4 , 6); R12(b2, c2, d2, e2, a2, w3, 12);
R21(b1, c1, d1, e1, a1, w14, 7); R22(b2, c2, d2, e2, a2, w9 , 15); R11(a1, b1, c1, d1, e1, w15, 8);
R21(a1, b1, c1, d1, e1, w11, 13); R22(a2, b2, c2, d2, e2, w1 , 13); R12(a2, b2, c2, d2, e2, w12, 6);
R21(e1, a1, b1, c1, d1, w8 , 12); R22(e2, a2, b2, c2, d2, w2 , 11);
R21(e1, a1, b1, c1, d1, w7, 7);
R31(d1, e1, a1, b1, c1, w3 , 11); R32(d2, e2, a2, b2, c2, w15, 9); R22(e2, a2, b2, c2, d2, w6, 9);
R31(c1, d1, e1, a1, b1, w10, 13); R32(c2, d2, e2, a2, b2, w5 , 7); R21(d1, e1, a1, b1, c1, w4, 6);
R31(b1, c1, d1, e1, a1, w14, 6); R32(b2, c2, d2, e2, a2, w1 , 15); R22(d2, e2, a2, b2, c2, w11, 13);
R31(a1, b1, c1, d1, e1, w4 , 7); R32(a2, b2, c2, d2, e2, w3 , 11); R21(c1, d1, e1, a1, b1, w13, 8);
R31(e1, a1, b1, c1, d1, w9 , 14); R32(e2, a2, b2, c2, d2, w7 , 8); R22(c2, d2, e2, a2, b2, w3, 15);
R31(d1, e1, a1, b1, c1, w15, 9); R32(d2, e2, a2, b2, c2, w14, 6); R21(b1, c1, d1, e1, a1, w1, 13);
R31(c1, d1, e1, a1, b1, w8 , 13); R32(c2, d2, e2, a2, b2, w6 , 6); R22(b2, c2, d2, e2, a2, w7, 7);
R31(b1, c1, d1, e1, a1, w1 , 15); R32(b2, c2, d2, e2, a2, w9 , 14); R21(a1, b1, c1, d1, e1, w10, 11);
R31(a1, b1, c1, d1, e1, w2 , 14); R32(a2, b2, c2, d2, e2, w11, 12); R22(a2, b2, c2, d2, e2, w0, 12);
R31(e1, a1, b1, c1, d1, w7 , 8); R32(e2, a2, b2, c2, d2, w8 , 13); R21(e1, a1, b1, c1, d1, w6, 9);
R31(d1, e1, a1, b1, c1, w0 , 13); R32(d2, e2, a2, b2, c2, w12, 5); R22(e2, a2, b2, c2, d2, w13, 8);
R31(c1, d1, e1, a1, b1, w6 , 6); R32(c2, d2, e2, a2, b2, w2 , 14); R21(d1, e1, a1, b1, c1, w15, 7);
R31(b1, c1, d1, e1, a1, w13, 5); R32(b2, c2, d2, e2, a2, w10, 13); R22(d2, e2, a2, b2, c2, w5, 9);
R31(a1, b1, c1, d1, e1, w11, 12); R32(a2, b2, c2, d2, e2, w0 , 13); R21(c1, d1, e1, a1, b1, w3, 15);
R31(e1, a1, b1, c1, d1, w5 , 7); R32(e2, a2, b2, c2, d2, w4 , 7); R22(c2, d2, e2, a2, b2, w10, 11);
R31(d1, e1, a1, b1, c1, w12, 5); R32(d2, e2, a2, b2, c2, w13, 5); R21(b1, c1, d1, e1, a1, w12, 7);
R22(b2, c2, d2, e2, a2, w14, 7);
R41(c1, d1, e1, a1, b1, w1 , 11); R42(c2, d2, e2, a2, b2, w8 , 15); R21(a1, b1, c1, d1, e1, w0, 12);
R41(b1, c1, d1, e1, a1, w9 , 12); R42(b2, c2, d2, e2, a2, w6 , 5); R22(a2, b2, c2, d2, e2, w15, 7);
R41(a1, b1, c1, d1, e1, w11, 14); R42(a2, b2, c2, d2, e2, w4 , 8); R21(e1, a1, b1, c1, d1, w9, 15);
R41(e1, a1, b1, c1, d1, w10, 15); R42(e2, a2, b2, c2, d2, w1 , 11); R22(e2, a2, b2, c2, d2, w8, 12);
R41(d1, e1, a1, b1, c1, w0 , 14); R42(d2, e2, a2, b2, c2, w3 , 14); R21(d1, e1, a1, b1, c1, w5, 9);
R41(c1, d1, e1, a1, b1, w8 , 15); R42(c2, d2, e2, a2, b2, w11, 14); R22(d2, e2, a2, b2, c2, w12, 7);
R41(b1, c1, d1, e1, a1, w12, 9); R42(b2, c2, d2, e2, a2, w15, 6); R21(c1, d1, e1, a1, b1, w2, 11);
R41(a1, b1, c1, d1, e1, w4 , 8); R42(a2, b2, c2, d2, e2, w0 , 14); R22(c2, d2, e2, a2, b2, w4, 6);
R41(e1, a1, b1, c1, d1, w13, 9); R42(e2, a2, b2, c2, d2, w5 , 6); R21(b1, c1, d1, e1, a1, w14, 7);
R41(d1, e1, a1, b1, c1, w3 , 14); R42(d2, e2, a2, b2, c2, w12, 9); R22(b2, c2, d2, e2, a2, w9, 15);
R41(c1, d1, e1, a1, b1, w7 , 5); R42(c2, d2, e2, a2, b2, w2 , 12); R21(a1, b1, c1, d1, e1, w11, 13);
R41(b1, c1, d1, e1, a1, w15, 6); R42(b2, c2, d2, e2, a2, w13, 9); R22(a2, b2, c2, d2, e2, w1, 13);
R41(a1, b1, c1, d1, e1, w14, 8); R42(a2, b2, c2, d2, e2, w9 , 12); R21(e1, a1, b1, c1, d1, w8, 12);
R41(e1, a1, b1, c1, d1, w5 , 6); R42(e2, a2, b2, c2, d2, w7 , 5); R22(e2, a2, b2, c2, d2, w2, 11);
R41(d1, e1, a1, b1, c1, w6 , 5); R42(d2, e2, a2, b2, c2, w10, 15);
R41(c1, d1, e1, a1, b1, w2 , 12); R42(c2, d2, e2, a2, b2, w14, 8); R31(d1, e1, a1, b1, c1, w3, 11);
R32(d2, e2, a2, b2, c2, w15, 9);
R51(b1, c1, d1, e1, a1, w4 , 9); R52(b2, c2, d2, e2, a2, w12, 8); R31(c1, d1, e1, a1, b1, w10, 13);
R51(a1, b1, c1, d1, e1, w0 , 15); R52(a2, b2, c2, d2, e2, w15, 5); R32(c2, d2, e2, a2, b2, w5, 7);
R51(e1, a1, b1, c1, d1, w5 , 5); R52(e2, a2, b2, c2, d2, w10, 12); R31(b1, c1, d1, e1, a1, w14, 6);
R51(d1, e1, a1, b1, c1, w9 , 11); R52(d2, e2, a2, b2, c2, w4 , 9); R32(b2, c2, d2, e2, a2, w1, 15);
R51(c1, d1, e1, a1, b1, w7 , 6); R52(c2, d2, e2, a2, b2, w1 , 12); R31(a1, b1, c1, d1, e1, w4, 7);
R51(b1, c1, d1, e1, a1, w12, 8); R52(b2, c2, d2, e2, a2, w5 , 5); R32(a2, b2, c2, d2, e2, w3, 11);
R51(a1, b1, c1, d1, e1, w2 , 13); R52(a2, b2, c2, d2, e2, w8 , 14); R31(e1, a1, b1, c1, d1, w9, 14);
R51(e1, a1, b1, c1, d1, w10, 12); R52(e2, a2, b2, c2, d2, w7 , 6); R32(e2, a2, b2, c2, d2, w7, 8);
R51(d1, e1, a1, b1, c1, w14, 5); R52(d2, e2, a2, b2, c2, w6 , 8); R31(d1, e1, a1, b1, c1, w15, 9);
R51(c1, d1, e1, a1, b1, w1 , 12); R52(c2, d2, e2, a2, b2, w2 , 13); R32(d2, e2, a2, b2, c2, w14, 6);
R51(b1, c1, d1, e1, a1, w3 , 13); R52(b2, c2, d2, e2, a2, w13, 6); R31(c1, d1, e1, a1, b1, w8, 13);
R51(a1, b1, c1, d1, e1, w8 , 14); R52(a2, b2, c2, d2, e2, w14, 5); R32(c2, d2, e2, a2, b2, w6, 6);
R51(e1, a1, b1, c1, d1, w11, 11); R52(e2, a2, b2, c2, d2, w0 , 15); R31(b1, c1, d1, e1, a1, w1, 15);
R51(d1, e1, a1, b1, c1, w6 , 8); R52(d2, e2, a2, b2, c2, w3 , 13); R32(b2, c2, d2, e2, a2, w9, 14);
R51(c1, d1, e1, a1, b1, w15, 5); R52(c2, d2, e2, a2, b2, w9 , 11); R31(a1, b1, c1, d1, e1, w2, 14);
R51(b1, c1, d1, e1, a1, w13, 6); R52(b2, c2, d2, e2, a2, w11, 11); R32(a2, b2, c2, d2, e2, w11, 12);
R31(e1, a1, b1, c1, d1, w7, 8);
R32(e2, a2, b2, c2, d2, w8, 13);
R31(d1, e1, a1, b1, c1, w0, 13);
R32(d2, e2, a2, b2, c2, w12, 5);
R31(c1, d1, e1, a1, b1, w6, 6);
R32(c2, d2, e2, a2, b2, w2, 14);
R31(b1, c1, d1, e1, a1, w13, 5);
R32(b2, c2, d2, e2, a2, w10, 13);
R31(a1, b1, c1, d1, e1, w11, 12);
R32(a2, b2, c2, d2, e2, w0, 13);
R31(e1, a1, b1, c1, d1, w5, 7);
R32(e2, a2, b2, c2, d2, w4, 7);
R31(d1, e1, a1, b1, c1, w12, 5);
R32(d2, e2, a2, b2, c2, w13, 5);
R41(c1, d1, e1, a1, b1, w1, 11);
R42(c2, d2, e2, a2, b2, w8, 15);
R41(b1, c1, d1, e1, a1, w9, 12);
R42(b2, c2, d2, e2, a2, w6, 5);
R41(a1, b1, c1, d1, e1, w11, 14);
R42(a2, b2, c2, d2, e2, w4, 8);
R41(e1, a1, b1, c1, d1, w10, 15);
R42(e2, a2, b2, c2, d2, w1, 11);
R41(d1, e1, a1, b1, c1, w0, 14);
R42(d2, e2, a2, b2, c2, w3, 14);
R41(c1, d1, e1, a1, b1, w8, 15);
R42(c2, d2, e2, a2, b2, w11, 14);
R41(b1, c1, d1, e1, a1, w12, 9);
R42(b2, c2, d2, e2, a2, w15, 6);
R41(a1, b1, c1, d1, e1, w4, 8);
R42(a2, b2, c2, d2, e2, w0, 14);
R41(e1, a1, b1, c1, d1, w13, 9);
R42(e2, a2, b2, c2, d2, w5, 6);
R41(d1, e1, a1, b1, c1, w3, 14);
R42(d2, e2, a2, b2, c2, w12, 9);
R41(c1, d1, e1, a1, b1, w7, 5);
R42(c2, d2, e2, a2, b2, w2, 12);
R41(b1, c1, d1, e1, a1, w15, 6);
R42(b2, c2, d2, e2, a2, w13, 9);
R41(a1, b1, c1, d1, e1, w14, 8);
R42(a2, b2, c2, d2, e2, w9, 12);
R41(e1, a1, b1, c1, d1, w5, 6);
R42(e2, a2, b2, c2, d2, w7, 5);
R41(d1, e1, a1, b1, c1, w6, 5);
R42(d2, e2, a2, b2, c2, w10, 15);
R41(c1, d1, e1, a1, b1, w2, 12);
R42(c2, d2, e2, a2, b2, w14, 8);
R51(b1, c1, d1, e1, a1, w4, 9);
R52(b2, c2, d2, e2, a2, w12, 8);
R51(a1, b1, c1, d1, e1, w0, 15);
R52(a2, b2, c2, d2, e2, w15, 5);
R51(e1, a1, b1, c1, d1, w5, 5);
R52(e2, a2, b2, c2, d2, w10, 12);
R51(d1, e1, a1, b1, c1, w9, 11);
R52(d2, e2, a2, b2, c2, w4, 9);
R51(c1, d1, e1, a1, b1, w7, 6);
R52(c2, d2, e2, a2, b2, w1, 12);
R51(b1, c1, d1, e1, a1, w12, 8);
R52(b2, c2, d2, e2, a2, w5, 5);
R51(a1, b1, c1, d1, e1, w2, 13);
R52(a2, b2, c2, d2, e2, w8, 14);
R51(e1, a1, b1, c1, d1, w10, 12);
R52(e2, a2, b2, c2, d2, w7, 6);
R51(d1, e1, a1, b1, c1, w14, 5);
R52(d2, e2, a2, b2, c2, w6, 8);
R51(c1, d1, e1, a1, b1, w1, 12);
R52(c2, d2, e2, a2, b2, w2, 13);
R51(b1, c1, d1, e1, a1, w3, 13);
R52(b2, c2, d2, e2, a2, w13, 6);
R51(a1, b1, c1, d1, e1, w8, 14);
R52(a2, b2, c2, d2, e2, w14, 5);
R51(e1, a1, b1, c1, d1, w11, 11);
R52(e2, a2, b2, c2, d2, w0, 15);
R51(d1, e1, a1, b1, c1, w6, 8);
R52(d2, e2, a2, b2, c2, w3, 13);
R51(c1, d1, e1, a1, b1, w15, 5);
R52(c2, d2, e2, a2, b2, w9, 11);
R51(b1, c1, d1, e1, a1, w13, 6);
R52(b2, c2, d2, e2, a2, w11, 11);
uint32_t t = s[0]; uint32_t t = s[0];
s[0] = s[1] + c1 + d2; s[0] = s[1] + c1 + d2;
@ -156,11 +239,13 @@ void Transform(uint32_t *s, const unsigned char *chunk) {
////// RIPEMD160 ////// RIPEMD160
CRIPEMD160::CRIPEMD160() : bytes(0) { CRIPEMD160::CRIPEMD160() : bytes(0)
{
ripemd160::Initialize(s); ripemd160::Initialize(s);
} }
CRIPEMD160& CRIPEMD160::Write(const unsigned char *data, size_t len) { CRIPEMD160& CRIPEMD160::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len; const unsigned char* end = data + len;
size_t bufsize = bytes % 64; size_t bufsize = bytes % 64;
if (bufsize && bufsize + len >= 64) { if (bufsize && bufsize + len >= 64) {
@ -185,7 +270,8 @@ CRIPEMD160& CRIPEMD160::Write(const unsigned char *data, size_t len) {
return *this; return *this;
} }
void CRIPEMD160::Finalize(unsigned char hash[OUTPUT_SIZE]) { void CRIPEMD160::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[64] = {0x80}; static const unsigned char pad[64] = {0x80};
unsigned char sizedesc[8]; unsigned char sizedesc[8];
WriteLE64(sizedesc, bytes << 3); WriteLE64(sizedesc, bytes << 3);
@ -198,7 +284,8 @@ void CRIPEMD160::Finalize(unsigned char hash[OUTPUT_SIZE]) {
WriteLE32(hash + 16, s[4]); WriteLE32(hash + 16, s[4]);
} }
CRIPEMD160& CRIPEMD160::Reset() { CRIPEMD160& CRIPEMD160::Reset()
{
bytes = 0; bytes = 0;
ripemd160::Initialize(s); ripemd160::Initialize(s);
return *this; return *this;

3
src/crypto/ripemd160.h
Unescape View File

@ -9,7 +9,8 @@
#include <stdlib.h> #include <stdlib.h>
/** A hasher class for RIPEMD-160. */ /** A hasher class for RIPEMD-160. */
class CRIPEMD160 { class CRIPEMD160
{
private: private:
uint32_t s[5]; uint32_t s[5];
unsigned char buf[64]; unsigned char buf[64];

30
src/crypto/sha1.cpp
Unescape View File

@ -9,14 +9,14 @@
#include <string.h> #include <string.h>
// Internal implementation code. // Internal implementation code.
namespace { namespace
{
/// Internal SHA-1 implementation. /// Internal SHA-1 implementation.
namespace sha1 { namespace sha1
{
/** One round of SHA-1. */ /** One round of SHA-1. */
void inline Round(uint32_t a, uint32_t &b, uint32_t c, uint32_t d, uint32_t &e, void inline Round(uint32_t a, uint32_t& b, uint32_t c, uint32_t d, uint32_t& e, uint32_t f, uint32_t k, uint32_t w)
uint32_t f, uint32_t k, uint32_t w) { {
e += ((a << 5) | (a >> 27)) + f + k + w; e += ((a << 5) | (a >> 27)) + f + k + w;
b = (b << 30) | (b >> 2); b = (b << 30) | (b >> 2);
} }
@ -28,7 +28,8 @@ uint32_t inline f3(uint32_t b, uint32_t c, uint32_t d) { return (b & c) | (d & (
uint32_t inline left(uint32_t x) { return (x << 1) | (x >> 31); } uint32_t inline left(uint32_t x) { return (x << 1) | (x >> 31); }
/** Initialize SHA-1 state. */ /** Initialize SHA-1 state. */
void inline Initialize(uint32_t *s) { void inline Initialize(uint32_t* s)
{
s[0] = 0x67452301ul; s[0] = 0x67452301ul;
s[1] = 0xEFCDAB89ul; s[1] = 0xEFCDAB89ul;
s[2] = 0x98BADCFEul; s[2] = 0x98BADCFEul;
@ -42,7 +43,8 @@ const uint32_t k3 = 0x8F1BBCDCul;
const uint32_t k4 = 0xCA62C1D6ul; const uint32_t k4 = 0xCA62C1D6ul;
/** Perform a SHA-1 transformation, processing a 64-byte chunk. */ /** Perform a SHA-1 transformation, processing a 64-byte chunk. */
void Transform(uint32_t *s, const unsigned char *chunk) { void Transform(uint32_t* s, const unsigned char* chunk)
{
uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4]; uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4];
uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15; uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
@ -144,11 +146,13 @@ void Transform(uint32_t *s, const unsigned char *chunk) {
////// SHA1 ////// SHA1
CSHA1::CSHA1() : bytes(0) { CSHA1::CSHA1() : bytes(0)
{
sha1::Initialize(s); sha1::Initialize(s);
} }
CSHA1& CSHA1::Write(const unsigned char *data, size_t len) { CSHA1& CSHA1::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len; const unsigned char* end = data + len;
size_t bufsize = bytes % 64; size_t bufsize = bytes % 64;
if (bufsize && bufsize + len >= 64) { if (bufsize && bufsize + len >= 64) {
@ -173,7 +177,8 @@ CSHA1& CSHA1::Write(const unsigned char *data, size_t len) {
return *this; return *this;
} }
void CSHA1::Finalize(unsigned char hash[OUTPUT_SIZE]) { void CSHA1::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[64] = {0x80}; static const unsigned char pad[64] = {0x80};
unsigned char sizedesc[8]; unsigned char sizedesc[8];
WriteBE64(sizedesc, bytes << 3); WriteBE64(sizedesc, bytes << 3);
@ -186,7 +191,8 @@ void CSHA1::Finalize(unsigned char hash[OUTPUT_SIZE]) {
WriteBE32(hash + 16, s[4]); WriteBE32(hash + 16, s[4]);
} }
CSHA1& CSHA1::Reset() { CSHA1& CSHA1::Reset()
{
bytes = 0; bytes = 0;
sha1::Initialize(s); sha1::Initialize(s);
return *this; return *this;

3
src/crypto/sha1.h
Unescape View File

@ -9,7 +9,8 @@
#include <stdlib.h> #include <stdlib.h>
/** A hasher class for SHA1. */ /** A hasher class for SHA1. */
class CSHA1 { class CSHA1
{
private: private:
uint32_t s[5]; uint32_t s[5];
unsigned char buf[64]; unsigned char buf[64];

64
src/crypto/sha2.cpp
Unescape View File

@ -9,11 +9,11 @@
#include <string.h> #include <string.h>
// Internal implementation code. // Internal implementation code.
namespace { namespace
{
/// Internal SHA-256 implementation. /// Internal SHA-256 implementation.
namespace sha256 { namespace sha256
{
uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); } uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); } uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); }
uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); } uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); }
@ -22,9 +22,8 @@ uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x <<
uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); } uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); }
/** One round of SHA-256. */ /** One round of SHA-256. */
void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t &d, void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k, uint32_t w)
uint32_t e, uint32_t f, uint32_t g, uint32_t &h, {
uint32_t k, uint32_t w) {
uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w; uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w;
uint32_t t2 = Sigma0(a) + Maj(a, b, c); uint32_t t2 = Sigma0(a) + Maj(a, b, c);
d += t1; d += t1;
@ -32,7 +31,8 @@ void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t &d,
} }
/** Initialize SHA-256 state. */ /** Initialize SHA-256 state. */
void inline Initialize(uint32_t *s) { void inline Initialize(uint32_t* s)
{
s[0] = 0x6a09e667ul; s[0] = 0x6a09e667ul;
s[1] = 0xbb67ae85ul; s[1] = 0xbb67ae85ul;
s[2] = 0x3c6ef372ul; s[2] = 0x3c6ef372ul;
@ -44,7 +44,8 @@ void inline Initialize(uint32_t *s) {
} }
/** Perform one SHA-256 transformation, processing a 64-byte chunk. */ /** Perform one SHA-256 transformation, processing a 64-byte chunk. */
void Transform(uint32_t *s, const unsigned char *chunk) { void Transform(uint32_t* s, const unsigned char* chunk)
{
uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7]; uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15; uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
@ -129,8 +130,8 @@ void Transform(uint32_t *s, const unsigned char *chunk) {
} // namespace sha256 } // namespace sha256
/// Internal SHA-512 implementation. /// Internal SHA-512 implementation.
namespace sha512 { namespace sha512
{
uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x & (y ^ z)); } uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x & (y ^ z)); }
uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & y) | (z & (x | y)); } uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & y) | (z & (x | y)); }
uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >> 34 | x << 30) ^ (x >> 39 | x << 25); } uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >> 34 | x << 30) ^ (x >> 39 | x << 25); }
@ -139,9 +140,8 @@ uint64_t inline sigma0(uint64_t x) { return (x >> 1 | x << 63) ^ (x >> 8 | x <<
uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >> 61 | x << 3) ^ (x >> 6); } uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >> 61 | x << 3) ^ (x >> 6); }
/** One round of SHA-512. */ /** One round of SHA-512. */
void inline Round(uint64_t a, uint64_t b, uint64_t c, uint64_t &d, void inline Round(uint64_t a, uint64_t b, uint64_t c, uint64_t& d, uint64_t e, uint64_t f, uint64_t g, uint64_t& h, uint64_t k, uint64_t w)
uint64_t e, uint64_t f, uint64_t g, uint64_t &h, {
uint64_t k, uint64_t w) {
uint64_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w; uint64_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w;
uint64_t t2 = Sigma0(a) + Maj(a, b, c); uint64_t t2 = Sigma0(a) + Maj(a, b, c);
d += t1; d += t1;
@ -149,7 +149,8 @@ void inline Round(uint64_t a, uint64_t b, uint64_t c, uint64_t &d,
} }
/** Initialize SHA-256 state. */ /** Initialize SHA-256 state. */
void inline Initialize(uint64_t *s) { void inline Initialize(uint64_t* s)
{
s[0] = 0x6a09e667f3bcc908ull; s[0] = 0x6a09e667f3bcc908ull;
s[1] = 0xbb67ae8584caa73bull; s[1] = 0xbb67ae8584caa73bull;
s[2] = 0x3c6ef372fe94f82bull; s[2] = 0x3c6ef372fe94f82bull;
@ -161,7 +162,8 @@ void inline Initialize(uint64_t *s) {
} }
/** Perform one SHA-512 transformation, processing a 128-byte chunk. */ /** Perform one SHA-512 transformation, processing a 128-byte chunk. */
void Transform(uint64_t *s, const unsigned char *chunk) { void Transform(uint64_t* s, const unsigned char* chunk)
{
uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7]; uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15; uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
@ -267,11 +269,13 @@ void Transform(uint64_t *s, const unsigned char *chunk) {
////// SHA-256 ////// SHA-256
CSHA256::CSHA256() : bytes(0) { CSHA256::CSHA256() : bytes(0)
{
sha256::Initialize(s); sha256::Initialize(s);
} }
CSHA256& CSHA256::Write(const unsigned char *data, size_t len) { CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len; const unsigned char* end = data + len;
size_t bufsize = bytes % 64; size_t bufsize = bytes % 64;
if (bufsize && bufsize + len >= 64) { if (bufsize && bufsize + len >= 64) {
@ -296,7 +300,8 @@ CSHA256& CSHA256::Write(const unsigned char *data, size_t len) {
return *this; return *this;
} }
void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE]) { void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[64] = {0x80}; static const unsigned char pad[64] = {0x80};
unsigned char sizedesc[8]; unsigned char sizedesc[8];
WriteBE64(sizedesc, bytes << 3); WriteBE64(sizedesc, bytes << 3);
@ -312,7 +317,8 @@ void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE]) {
WriteBE32(hash + 28, s[7]); WriteBE32(hash + 28, s[7]);
} }
CSHA256& CSHA256::Reset() { CSHA256& CSHA256::Reset()
{
bytes = 0; bytes = 0;
sha256::Initialize(s); sha256::Initialize(s);
return *this; return *this;
@ -320,11 +326,13 @@ CSHA256& CSHA256::Reset() {
////// SHA-512 ////// SHA-512
CSHA512::CSHA512() : bytes(0) { CSHA512::CSHA512() : bytes(0)
{
sha512::Initialize(s); sha512::Initialize(s);
} }
CSHA512& CSHA512::Write(const unsigned char *data, size_t len) { CSHA512& CSHA512::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len; const unsigned char* end = data + len;
size_t bufsize = bytes % 128; size_t bufsize = bytes % 128;
if (bufsize && bufsize + len >= 128) { if (bufsize && bufsize + len >= 128) {
@ -349,7 +357,8 @@ CSHA512& CSHA512::Write(const unsigned char *data, size_t len) {
return *this; return *this;
} }
void CSHA512::Finalize(unsigned char hash[OUTPUT_SIZE]) { void CSHA512::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[128] = {0x80}; static const unsigned char pad[128] = {0x80};
unsigned char sizedesc[16] = {0x00}; unsigned char sizedesc[16] = {0x00};
WriteBE64(sizedesc + 8, bytes << 3); WriteBE64(sizedesc + 8, bytes << 3);
@ -365,7 +374,8 @@ void CSHA512::Finalize(unsigned char hash[OUTPUT_SIZE]) {
WriteBE64(hash + 56, s[7]); WriteBE64(hash + 56, s[7]);
} }
CSHA512& CSHA512::Reset() { CSHA512& CSHA512::Reset()
{
bytes = 0; bytes = 0;
sha512::Initialize(s); sha512::Initialize(s);
return *this; return *this;
@ -373,7 +383,8 @@ CSHA512& CSHA512::Reset() {
////// HMAC-SHA-512 ////// HMAC-SHA-512
CHMAC_SHA512::CHMAC_SHA512(const unsigned char *key, size_t keylen) { CHMAC_SHA512::CHMAC_SHA512(const unsigned char* key, size_t keylen)
{
unsigned char rkey[128]; unsigned char rkey[128];
if (keylen <= 128) { if (keylen <= 128) {
memcpy(rkey, key, keylen); memcpy(rkey, key, keylen);
@ -392,7 +403,8 @@ CHMAC_SHA512::CHMAC_SHA512(const unsigned char *key, size_t keylen) {
inner.Write(rkey, 128); inner.Write(rkey, 128);
} }
void CHMAC_SHA512::Finalize(unsigned char hash[OUTPUT_SIZE]) { void CHMAC_SHA512::Finalize(unsigned char hash[OUTPUT_SIZE])
{
unsigned char temp[64]; unsigned char temp[64];
inner.Finalize(temp); inner.Finalize(temp);
outer.Write(temp, 64).Finalize(hash); outer.Write(temp, 64).Finalize(hash);

12
src/crypto/sha2.h
Unescape View File

@ -9,7 +9,8 @@
#include <stdlib.h> #include <stdlib.h>
/** A hasher class for SHA-256. */ /** A hasher class for SHA-256. */
class CSHA256 { class CSHA256
{
private: private:
uint32_t s[8]; uint32_t s[8];
unsigned char buf[64]; unsigned char buf[64];
@ -25,7 +26,8 @@ public:
}; };
/** A hasher class for SHA-512. */ /** A hasher class for SHA-512. */
class CSHA512 { class CSHA512
{
private: private:
uint64_t s[8]; uint64_t s[8];
unsigned char buf[128]; unsigned char buf[128];
@ -41,7 +43,8 @@ public:
}; };
/** A hasher class for HMAC-SHA-512. */ /** A hasher class for HMAC-SHA-512. */
class CHMAC_SHA512 { class CHMAC_SHA512
{
private: private:
CSHA512 outer; CSHA512 outer;
CSHA512 inner; CSHA512 inner;
@ -50,7 +53,8 @@ public:
static const size_t OUTPUT_SIZE = 64; static const size_t OUTPUT_SIZE = 64;
CHMAC_SHA512(const unsigned char* key, size_t keylen); CHMAC_SHA512(const unsigned char* key, size_t keylen);
CHMAC_SHA512& Write(const unsigned char *data, size_t len) { CHMAC_SHA512& Write(const unsigned char* data, size_t len)
{
inner.Write(data, len); inner.Write(data, len);
return *this; return *this;
} }

Write Preview
Loading…
Cancel
Save