From 149f94f9fc19109e4db5c94fd0603df1568ee160 Mon Sep 17 00:00:00 2001 From: Julian Storer Date: Mon, 19 Sep 2011 12:29:25 +0100 Subject: [PATCH] Got rid of the MD5 (const String&) constructor that was confusing people - if you were using that constructuor, you can now call fromUTF32() instead for the same result. Also added a constructor that takes UTF-8 instead, and this is recommended. --- .../encryption/juce_BlowFish.cpp | 6 +- .../encryption/juce_BlowFish.h | 6 +- .../juce_cryptography/hashing/juce_MD5.cpp | 419 +++++++++--------- modules/juce_cryptography/hashing/juce_MD5.h | 62 ++- .../juce_cryptography/hashing/juce_SHA256.cpp | 8 +- .../juce_cryptography/hashing/juce_SHA256.h | 12 +- 6 files changed, 251 insertions(+), 262 deletions(-) diff --git a/modules/juce_cryptography/encryption/juce_BlowFish.cpp b/modules/juce_cryptography/encryption/juce_BlowFish.cpp index c9612bfe02..e4765774b4 100644 --- a/modules/juce_cryptography/encryption/juce_BlowFish.cpp +++ b/modules/juce_cryptography/encryption/juce_BlowFish.cpp @@ -224,7 +224,7 @@ BlowFish::BlowFish (const BlowFish& other) operator= (other); } -BlowFish& BlowFish::operator= (const BlowFish& other) +BlowFish& BlowFish::operator= (const BlowFish& other) noexcept { memcpy (p, other.p, sizeof (p)); @@ -234,9 +234,7 @@ BlowFish& BlowFish::operator= (const BlowFish& other) return *this; } -BlowFish::~BlowFish() -{ -} +BlowFish::~BlowFish() noexcept {} uint32 BlowFish::F (const uint32 x) const noexcept { diff --git a/modules/juce_cryptography/encryption/juce_BlowFish.h b/modules/juce_cryptography/encryption/juce_BlowFish.h index 277182871c..13060f5ac7 100644 --- a/modules/juce_cryptography/encryption/juce_BlowFish.h +++ b/modules/juce_cryptography/encryption/juce_BlowFish.h @@ -46,10 +46,10 @@ public: BlowFish (const BlowFish& other); /** Copies another blowfish object. */ - BlowFish& operator= (const BlowFish& other); + BlowFish& operator= (const BlowFish& other) noexcept; /** Destructor. */ - ~BlowFish(); + ~BlowFish() noexcept; //============================================================================== /** Encrypts a pair of 32-bit integers. */ @@ -64,7 +64,7 @@ private: uint32 p[18]; HeapBlock s[4]; - uint32 F (uint32 x) const noexcept; + uint32 F (uint32) const noexcept; JUCE_LEAK_DETECTOR (BlowFish); }; diff --git a/modules/juce_cryptography/hashing/juce_MD5.cpp b/modules/juce_cryptography/hashing/juce_MD5.cpp index c79b81c7fd..a68321c9f4 100644 --- a/modules/juce_cryptography/hashing/juce_MD5.cpp +++ b/modules/juce_cryptography/hashing/juce_MD5.cpp @@ -25,76 +25,221 @@ BEGIN_JUCE_NAMESPACE + //============================================================================== -MD5::MD5() +class MD5Generator +{ +public: + MD5Generator() noexcept + { + state[0] = 0x67452301; + state[1] = 0xefcdab89; + state[2] = 0x98badcfe; + state[3] = 0x10325476; + + count[0] = 0; + count[1] = 0; + } + + void processBlock (const void* data, size_t dataSize) noexcept + { + int bufferPos = ((count[0] >> 3) & 0x3F); + + count[0] += (uint32) (dataSize << 3); + + if (count[0] < ((uint32) dataSize << 3)) + count[1]++; + + count[1] += (uint32) (dataSize >> 29); + + const size_t spaceLeft = 64 - bufferPos; + size_t i = 0; + + if (dataSize >= spaceLeft) + { + memcpy (buffer + bufferPos, data, spaceLeft); + transform (buffer); + + for (i = spaceLeft; i + 64 <= dataSize; i += 64) + transform (static_cast (data) + i); + + bufferPos = 0; + } + + memcpy (buffer + bufferPos, static_cast (data) + i, dataSize - i); + } + + void transform (const void* bufferToTransform) noexcept + { + uint32 a = state[0]; + uint32 b = state[1]; + uint32 c = state[2]; + uint32 d = state[3]; + uint32 x[16]; + + encode (x, bufferToTransform, 64); + + enum Constants + { + S11 = 7, S12 = 12, S13 = 17, S14 = 22, S21 = 5, S22 = 9, S23 = 14, S24 = 20, + S31 = 4, S32 = 11, S33 = 16, S34 = 23, S41 = 6, S42 = 10, S43 = 15, S44 = 21 + }; + + FF (a, b, c, d, x[ 0], S11, 0xd76aa478); FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); + FF (c, d, a, b, x[ 2], S13, 0x242070db); FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); + FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); FF (d, a, b, c, x[ 5], S12, 0x4787c62a); + FF (c, d, a, b, x[ 6], S13, 0xa8304613); FF (b, c, d, a, x[ 7], S14, 0xfd469501); + FF (a, b, c, d, x[ 8], S11, 0x698098d8); FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); + FF (c, d, a, b, x[10], S13, 0xffff5bb1); FF (b, c, d, a, x[11], S14, 0x895cd7be); + FF (a, b, c, d, x[12], S11, 0x6b901122); FF (d, a, b, c, x[13], S12, 0xfd987193); + FF (c, d, a, b, x[14], S13, 0xa679438e); FF (b, c, d, a, x[15], S14, 0x49b40821); + + GG (a, b, c, d, x[ 1], S21, 0xf61e2562); GG (d, a, b, c, x[ 6], S22, 0xc040b340); + GG (c, d, a, b, x[11], S23, 0x265e5a51); GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); + GG (a, b, c, d, x[ 5], S21, 0xd62f105d); GG (d, a, b, c, x[10], S22, 0x02441453); + GG (c, d, a, b, x[15], S23, 0xd8a1e681); GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); + GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); GG (d, a, b, c, x[14], S22, 0xc33707d6); + GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); GG (b, c, d, a, x[ 8], S24, 0x455a14ed); + GG (a, b, c, d, x[13], S21, 0xa9e3e905); GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); + GG (c, d, a, b, x[ 7], S23, 0x676f02d9); GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); + + HH (a, b, c, d, x[ 5], S31, 0xfffa3942); HH (d, a, b, c, x[ 8], S32, 0x8771f681); + HH (c, d, a, b, x[11], S33, 0x6d9d6122); HH (b, c, d, a, x[14], S34, 0xfde5380c); + HH (a, b, c, d, x[ 1], S31, 0xa4beea44); HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); + HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); HH (b, c, d, a, x[10], S34, 0xbebfbc70); + HH (a, b, c, d, x[13], S31, 0x289b7ec6); HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); + HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); HH (b, c, d, a, x[ 6], S34, 0x04881d05); + HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); HH (d, a, b, c, x[12], S32, 0xe6db99e5); + HH (c, d, a, b, x[15], S33, 0x1fa27cf8); HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); + + II (a, b, c, d, x[ 0], S41, 0xf4292244); II (d, a, b, c, x[ 7], S42, 0x432aff97); + II (c, d, a, b, x[14], S43, 0xab9423a7); II (b, c, d, a, x[ 5], S44, 0xfc93a039); + II (a, b, c, d, x[12], S41, 0x655b59c3); II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); + II (c, d, a, b, x[10], S43, 0xffeff47d); II (b, c, d, a, x[ 1], S44, 0x85845dd1); + II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); II (d, a, b, c, x[15], S42, 0xfe2ce6e0); + II (c, d, a, b, x[ 6], S43, 0xa3014314); II (b, c, d, a, x[13], S44, 0x4e0811a1); + II (a, b, c, d, x[ 4], S41, 0xf7537e82); II (d, a, b, c, x[11], S42, 0xbd3af235); + II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); II (b, c, d, a, x[ 9], S44, 0xeb86d391); + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + zerostruct (x); + } + + void finish (void* result) noexcept + { + unsigned char encodedLength[8]; + encode (encodedLength, count, 8); + + // Pad out to 56 mod 64. + const int index = (uint32) ((count[0] >> 3) & 0x3f); + + const int paddingLength = (index < 56) ? (56 - index) + : (120 - index); + + uint8 paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero. + processBlock (paddingBuffer, paddingLength); + + processBlock (encodedLength, 8); + + encode (result, state, 16); + zerostruct (buffer); + } + +private: + uint8 buffer [64]; + uint32 state [4]; + uint32 count [2]; + + static void encode (void* const output, const void* const input, const int numBytes) noexcept + { + for (int i = 0; i < (numBytes >> 2); ++i) + static_cast (output)[i] = ByteOrder::swapIfBigEndian (static_cast (input) [i]); + } + + static inline uint32 rotateLeft (const uint32 x, const uint32 n) noexcept { return (x << n) | (x >> (32 - n)); } + + static inline uint32 F (const uint32 x, const uint32 y, const uint32 z) noexcept { return (x & y) | (~x & z); } + static inline uint32 G (const uint32 x, const uint32 y, const uint32 z) noexcept { return (x & z) | (y & ~z); } + static inline uint32 H (const uint32 x, const uint32 y, const uint32 z) noexcept { return x ^ y ^ z; } + static inline uint32 I (const uint32 x, const uint32 y, const uint32 z) noexcept { return y ^ (x | ~z); } + + static void FF (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept + { + a += F (b, c, d) + x + ac; + a = rotateLeft (a, s) + b; + } + + static void GG (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept + { + a += G (b, c, d) + x + ac; + a = rotateLeft (a, s) + b; + } + + static void HH (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept + { + a += H (b, c, d) + x + ac; + a = rotateLeft (a, s) + b; + } + + static void II (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept + { + a += I (b, c, d) + x + ac; + a = rotateLeft (a, s) + b; + } +}; + +//============================================================================== +MD5::MD5() noexcept { zerostruct (result); } -MD5::MD5 (const MD5& other) +MD5::MD5 (const MD5& other) noexcept { memcpy (result, other.result, sizeof (result)); } -MD5& MD5::operator= (const MD5& other) +MD5& MD5::operator= (const MD5& other) noexcept { memcpy (result, other.result, sizeof (result)); return *this; } //============================================================================== -MD5::MD5 (const MemoryBlock& data) +MD5::MD5 (const MemoryBlock& data) noexcept { - ProcessContext context; - context.processBlock (data.getData(), data.getSize()); - context.finish (result); + processData (data.getData(), data.getSize()); } -MD5::MD5 (const void* data, const size_t numBytes) +MD5::MD5 (const void* data, const size_t numBytes) noexcept { - ProcessContext context; - context.processBlock (data, numBytes); - context.finish (result); + processData (data, numBytes); } -MD5::MD5 (const String& text) +MD5::MD5 (const CharPointer_UTF8& utf8) noexcept { - ProcessContext context; + jassert (utf8.getAddress() != nullptr); + processData (utf8.getAddress(), utf8.sizeInBytes() - 1); +} + +MD5 MD5::fromUTF32 (const String& text) +{ + MD5Generator generator; String::CharPointerType t (text.getCharPointer()); while (! t.isEmpty()) { - // force the string into integer-sized unicode characters, to try to make it - // get the same results on all platforms + compilers. uint32 unicodeChar = ByteOrder::swapIfBigEndian ((uint32) t.getAndAdvance()); - - context.processBlock (&unicodeChar, sizeof (unicodeChar)); + generator.processBlock (&unicodeChar, sizeof (unicodeChar)); } - context.finish (result); -} - -void MD5::processStream (InputStream& input, int64 numBytesToRead) -{ - ProcessContext context; - - if (numBytesToRead < 0) - numBytesToRead = std::numeric_limits::max(); - - while (numBytesToRead > 0) - { - uint8 tempBuffer [512]; - const int bytesRead = input.read (tempBuffer, (int) jmin (numBytesToRead, (int64) sizeof (tempBuffer))); - - if (bytesRead <= 0) - break; - - numBytesToRead -= bytesRead; - - context.processBlock (tempBuffer, bytesRead); - } - - context.finish (result); + MD5 m; + generator.finish (m.result); + return m; } MD5::MD5 (InputStream& input, int64 numBytesToRead) @@ -112,172 +257,35 @@ MD5::MD5 (const File& file) zerostruct (result); } -MD5::~MD5() +MD5::~MD5() noexcept {} + +void MD5::processData (const void* data, size_t numBytes) noexcept { + MD5Generator generator; + generator.processBlock (data, numBytes); + generator.finish (result); } -//============================================================================== -namespace MD5Functions +void MD5::processStream (InputStream& input, int64 numBytesToRead) { - void encode (void* const output, const void* const input, const int numBytes) noexcept + MD5Generator generator; + + if (numBytesToRead < 0) + numBytesToRead = std::numeric_limits::max(); + + while (numBytesToRead > 0) { - for (int i = 0; i < (numBytes >> 2); ++i) - static_cast (output)[i] = ByteOrder::swapIfBigEndian (static_cast (input) [i]); + uint8 tempBuffer [512]; + const int bytesRead = input.read (tempBuffer, (int) jmin (numBytesToRead, (int64) sizeof (tempBuffer))); + + if (bytesRead <= 0) + break; + + numBytesToRead -= bytesRead; + generator.processBlock (tempBuffer, bytesRead); } - inline uint32 rotateLeft (const uint32 x, const uint32 n) noexcept { return (x << n) | (x >> (32 - n)); } - - inline uint32 F (const uint32 x, const uint32 y, const uint32 z) noexcept { return (x & y) | (~x & z); } - inline uint32 G (const uint32 x, const uint32 y, const uint32 z) noexcept { return (x & z) | (y & ~z); } - inline uint32 H (const uint32 x, const uint32 y, const uint32 z) noexcept { return x ^ y ^ z; } - inline uint32 I (const uint32 x, const uint32 y, const uint32 z) noexcept { return y ^ (x | ~z); } - - void FF (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept - { - a += F (b, c, d) + x + ac; - a = rotateLeft (a, s) + b; - } - - void GG (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept - { - a += G (b, c, d) + x + ac; - a = rotateLeft (a, s) + b; - } - - void HH (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept - { - a += H (b, c, d) + x + ac; - a = rotateLeft (a, s) + b; - } - - void II (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept - { - a += I (b, c, d) + x + ac; - a = rotateLeft (a, s) + b; - } -} - -//============================================================================== -MD5::ProcessContext::ProcessContext() -{ - state[0] = 0x67452301; - state[1] = 0xefcdab89; - state[2] = 0x98badcfe; - state[3] = 0x10325476; - - count[0] = 0; - count[1] = 0; -} - -void MD5::ProcessContext::processBlock (const void* const data, const size_t dataSize) -{ - int bufferPos = ((count[0] >> 3) & 0x3F); - - count[0] += (uint32) (dataSize << 3); - - if (count[0] < ((uint32) dataSize << 3)) - count[1]++; - - count[1] += (uint32) (dataSize >> 29); - - const size_t spaceLeft = 64 - bufferPos; - size_t i = 0; - - if (dataSize >= spaceLeft) - { - memcpy (buffer + bufferPos, data, spaceLeft); - transform (buffer); - - for (i = spaceLeft; i + 64 <= dataSize; i += 64) - transform (static_cast (data) + i); - - bufferPos = 0; - } - - memcpy (buffer + bufferPos, static_cast (data) + i, dataSize - i); -} - -//============================================================================== -void MD5::ProcessContext::finish (void* const result) -{ - unsigned char encodedLength[8]; - MD5Functions::encode (encodedLength, count, 8); - - // Pad out to 56 mod 64. - const int index = (uint32) ((count[0] >> 3) & 0x3f); - - const int paddingLength = (index < 56) ? (56 - index) - : (120 - index); - - uint8 paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero. - processBlock (paddingBuffer, paddingLength); - - processBlock (encodedLength, 8); - - MD5Functions::encode (result, state, 16); - zerostruct (buffer); -} - -void MD5::ProcessContext::transform (const void* const bufferToTransform) -{ - using namespace MD5Functions; - - uint32 a = state[0]; - uint32 b = state[1]; - uint32 c = state[2]; - uint32 d = state[3]; - uint32 x[16]; - - encode (x, bufferToTransform, 64); - - enum Constants - { - S11 = 7, S12 = 12, S13 = 17, S14 = 22, S21 = 5, S22 = 9, S23 = 14, S24 = 20, - S31 = 4, S32 = 11, S33 = 16, S34 = 23, S41 = 6, S42 = 10, S43 = 15, S44 = 21 - }; - - FF (a, b, c, d, x[ 0], S11, 0xd76aa478); FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); - FF (c, d, a, b, x[ 2], S13, 0x242070db); FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); - FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); FF (d, a, b, c, x[ 5], S12, 0x4787c62a); - FF (c, d, a, b, x[ 6], S13, 0xa8304613); FF (b, c, d, a, x[ 7], S14, 0xfd469501); - FF (a, b, c, d, x[ 8], S11, 0x698098d8); FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); - FF (c, d, a, b, x[10], S13, 0xffff5bb1); FF (b, c, d, a, x[11], S14, 0x895cd7be); - FF (a, b, c, d, x[12], S11, 0x6b901122); FF (d, a, b, c, x[13], S12, 0xfd987193); - FF (c, d, a, b, x[14], S13, 0xa679438e); FF (b, c, d, a, x[15], S14, 0x49b40821); - - GG (a, b, c, d, x[ 1], S21, 0xf61e2562); GG (d, a, b, c, x[ 6], S22, 0xc040b340); - GG (c, d, a, b, x[11], S23, 0x265e5a51); GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); - GG (a, b, c, d, x[ 5], S21, 0xd62f105d); GG (d, a, b, c, x[10], S22, 0x02441453); - GG (c, d, a, b, x[15], S23, 0xd8a1e681); GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); - GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); GG (d, a, b, c, x[14], S22, 0xc33707d6); - GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); GG (b, c, d, a, x[ 8], S24, 0x455a14ed); - GG (a, b, c, d, x[13], S21, 0xa9e3e905); GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); - GG (c, d, a, b, x[ 7], S23, 0x676f02d9); GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); - - HH (a, b, c, d, x[ 5], S31, 0xfffa3942); HH (d, a, b, c, x[ 8], S32, 0x8771f681); - HH (c, d, a, b, x[11], S33, 0x6d9d6122); HH (b, c, d, a, x[14], S34, 0xfde5380c); - HH (a, b, c, d, x[ 1], S31, 0xa4beea44); HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); - HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); HH (b, c, d, a, x[10], S34, 0xbebfbc70); - HH (a, b, c, d, x[13], S31, 0x289b7ec6); HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); - HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); HH (b, c, d, a, x[ 6], S34, 0x04881d05); - HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); HH (d, a, b, c, x[12], S32, 0xe6db99e5); - HH (c, d, a, b, x[15], S33, 0x1fa27cf8); HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); - - II (a, b, c, d, x[ 0], S41, 0xf4292244); II (d, a, b, c, x[ 7], S42, 0x432aff97); - II (c, d, a, b, x[14], S43, 0xab9423a7); II (b, c, d, a, x[ 5], S44, 0xfc93a039); - II (a, b, c, d, x[12], S41, 0x655b59c3); II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); - II (c, d, a, b, x[10], S43, 0xffeff47d); II (b, c, d, a, x[ 1], S44, 0x85845dd1); - II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); II (d, a, b, c, x[15], S42, 0xfe2ce6e0); - II (c, d, a, b, x[ 6], S43, 0xa3014314); II (b, c, d, a, x[13], S44, 0x4e0811a1); - II (a, b, c, d, x[ 4], S41, 0xf7537e82); II (d, a, b, c, x[11], S42, 0xbd3af235); - II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); II (b, c, d, a, x[ 9], S44, 0xeb86d391); - - state[0] += a; - state[1] += b; - state[2] += c; - state[3] += d; - - zerostruct (x); + generator.finish (result); } //============================================================================== @@ -292,14 +300,7 @@ String MD5::toHexString() const } //============================================================================== -bool MD5::operator== (const MD5& other) const -{ - return memcmp (result, other.result, sizeof (result)) == 0; -} - -bool MD5::operator!= (const MD5& other) const -{ - return ! operator== (other); -} +bool MD5::operator== (const MD5& other) const noexcept { return memcmp (result, other.result, sizeof (result)) == 0; } +bool MD5::operator!= (const MD5& other) const noexcept { return ! operator== (other); } END_JUCE_NAMESPACE diff --git a/modules/juce_cryptography/hashing/juce_MD5.h b/modules/juce_cryptography/hashing/juce_MD5.h index a5b1c789bb..83a03cb7ce 100644 --- a/modules/juce_cryptography/hashing/juce_MD5.h +++ b/modules/juce_cryptography/hashing/juce_MD5.h @@ -41,30 +41,20 @@ class JUCE_API MD5 public: //============================================================================== /** Creates a null MD5 object. */ - MD5(); + MD5() noexcept; /** Creates a copy of another MD5. */ - MD5 (const MD5& other); + MD5 (const MD5& other) noexcept; /** Copies another MD5. */ - MD5& operator= (const MD5& other); + MD5& operator= (const MD5& other) noexcept; //============================================================================== /** Creates a checksum for a block of binary data. */ - explicit MD5 (const MemoryBlock& data); + explicit MD5 (const MemoryBlock& data) noexcept; /** Creates a checksum for a block of binary data. */ - MD5 (const void* data, size_t numBytes); - - /** Creates a checksum for a string. - - Note that this operates on the string as a block of unicode characters, so the - result you get will differ from the value you'd get if the string was treated - as a block of utf8 or ascii. Bear this in mind if you're comparing the result - of this method with a checksum created by a different framework, which may have - used a different encoding. - */ - explicit MD5 (const String& text); + MD5 (const void* data, size_t numBytes) noexcept; /** Creates a checksum for the input from a stream. @@ -77,46 +67,46 @@ public: /** Creates a checksum for a file. */ explicit MD5 (const File& file); + /** Creates a checksum from a UTF-8 buffer. + E.g. + @code MD5 checksum (myString.toUTF8()); + @endcode + */ + MD5 (const CharPointer_UTF8& utf8Text) noexcept; + /** Destructor. */ - ~MD5(); + ~MD5() noexcept; //============================================================================== /** Returns the checksum as a 16-byte block of data. */ MemoryBlock getRawChecksumData() const; /** Returns a pointer to the 16-byte array of result data. */ - const uint8* getChecksumDataArray() const noexcept { return result; } + const uint8* getChecksumDataArray() const noexcept { return result; } /** Returns the checksum as a 32-digit hex string. */ String toHexString() const; + /** Creates an MD5 from a little-endian UTF-32 encoded string. + + Note that this method is provided for backwards-compatibility with the old + version of this class, which had a constructor that took a string and performed + this operation on it. In new code, you shouldn't use this, and are recommended to + use the constructor that takes a CharPointer_UTF8 instead. + */ + static MD5 fromUTF32 (const String&); //============================================================================== - /** Compares this to another MD5. */ - bool operator== (const MD5& other) const; - - /** Compares this to another MD5. */ - bool operator!= (const MD5& other) const; + bool operator== (const MD5&) const noexcept; + bool operator!= (const MD5&) const noexcept; private: //============================================================================== uint8 result [16]; - struct ProcessContext - { - uint8 buffer [64]; - uint32 state [4]; - uint32 count [2]; - - ProcessContext(); - - void processBlock (const void* data, size_t dataSize); - void transform (const void* buffer); - void finish (void* result); - }; - - void processStream (InputStream&, int64 numBytesToRead); + void processData (const void*, size_t) noexcept; + void processStream (InputStream&, int64); JUCE_LEAK_DETECTOR (MD5); }; diff --git a/modules/juce_cryptography/hashing/juce_SHA256.cpp b/modules/juce_cryptography/hashing/juce_SHA256.cpp index c9544febfd..f8f197f413 100644 --- a/modules/juce_cryptography/hashing/juce_SHA256.cpp +++ b/modules/juce_cryptography/hashing/juce_SHA256.cpp @@ -156,19 +156,19 @@ private: }; //============================================================================== -SHA256::SHA256() +SHA256::SHA256() noexcept { zerostruct (result); } -SHA256::~SHA256() {} +SHA256::~SHA256() noexcept {} -SHA256::SHA256 (const SHA256& other) +SHA256::SHA256 (const SHA256& other) noexcept { memcpy (result, other.result, sizeof (result)); } -SHA256& SHA256::operator= (const SHA256& other) +SHA256& SHA256::operator= (const SHA256& other) noexcept { memcpy (result, other.result, sizeof (result)); return *this; diff --git a/modules/juce_cryptography/hashing/juce_SHA256.h b/modules/juce_cryptography/hashing/juce_SHA256.h index 0915afbc75..ef4824cc5b 100644 --- a/modules/juce_cryptography/hashing/juce_SHA256.h +++ b/modules/juce_cryptography/hashing/juce_SHA256.h @@ -45,16 +45,16 @@ public: The default constructor just creates a hash filled with zeros. (This is not equal to the hash of an empty block of data). */ - SHA256(); + SHA256() noexcept; /** Destructor. */ - ~SHA256(); + ~SHA256() noexcept; /** Creates a copy of another SHA256. */ - SHA256 (const SHA256& other); + SHA256 (const SHA256& other) noexcept; /** Copies another SHA256. */ - SHA256& operator= (const SHA256& other); + SHA256& operator= (const SHA256& other) noexcept; //============================================================================== /** Creates a hash from a block of raw data. */ @@ -85,8 +85,8 @@ public: String toHexString() const; //============================================================================== - bool operator== (const SHA256& other) const noexcept; - bool operator!= (const SHA256& other) const noexcept; + bool operator== (const SHA256&) const noexcept; + bool operator!= (const SHA256&) const noexcept; private: