DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
Browse Source

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.

tags/2021-05-28
Julian Storer 14 years ago
parent
2d56bedab5
commit
149f94f9fc
6 changed files with 228 additions and 239 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -4
      modules/juce_cryptography/encryption/juce_BlowFish.cpp
  2. +3
    -3
      modules/juce_cryptography/encryption/juce_BlowFish.h
  3. +187
    -186
      modules/juce_cryptography/hashing/juce_MD5.cpp
  4. +26
    -36
      modules/juce_cryptography/hashing/juce_MD5.h
  5. +4
    -4
      modules/juce_cryptography/hashing/juce_SHA256.cpp
  6. +6
    -6
      modules/juce_cryptography/hashing/juce_SHA256.h

+ 2
- 4
modules/juce_cryptography/encryption/juce_BlowFish.cpp View File

@@ -224,7 +224,7 @@ BlowFish::BlowFish (const BlowFish& other)
operator= (other); operator= (other);
} }
BlowFish& BlowFish::operator= (const BlowFish& other)
BlowFish& BlowFish::operator= (const BlowFish& other) noexcept
{ {
memcpy (p, other.p, sizeof (p)); memcpy (p, other.p, sizeof (p));
@@ -234,9 +234,7 @@ BlowFish& BlowFish::operator= (const BlowFish& other)
return *this; return *this;
} }
BlowFish::~BlowFish()
{
}
BlowFish::~BlowFish() noexcept {}
uint32 BlowFish::F (const uint32 x) const noexcept uint32 BlowFish::F (const uint32 x) const noexcept
{ {


+ 3
- 3
modules/juce_cryptography/encryption/juce_BlowFish.h View File

@@ -46,10 +46,10 @@ public:
BlowFish (const BlowFish& other); BlowFish (const BlowFish& other);
/** Copies another blowfish object. */ /** Copies another blowfish object. */
BlowFish& operator= (const BlowFish& other);
BlowFish& operator= (const BlowFish& other) noexcept;
/** Destructor. */ /** Destructor. */
~BlowFish();
~BlowFish() noexcept;
//============================================================================== //==============================================================================
/** Encrypts a pair of 32-bit integers. */ /** Encrypts a pair of 32-bit integers. */
@@ -64,7 +64,7 @@ private:
uint32 p[18]; uint32 p[18];
HeapBlock <uint32> s[4]; HeapBlock <uint32> s[4];
uint32 F (uint32 x) const noexcept;
uint32 F (uint32) const noexcept;
JUCE_LEAK_DETECTOR (BlowFish); JUCE_LEAK_DETECTOR (BlowFish);
}; };


+ 187
- 186
modules/juce_cryptography/hashing/juce_MD5.cpp View File

@@ -25,259 +25,267 @@
BEGIN_JUCE_NAMESPACE BEGIN_JUCE_NAMESPACE
//============================================================================== //==============================================================================
MD5::MD5()
class MD5Generator
{ {
zerostruct (result);
}
public:
MD5Generator() noexcept
{
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
MD5::MD5 (const MD5& other)
{
memcpy (result, other.result, sizeof (result));
}
count[0] = 0;
count[1] = 0;
}
MD5& MD5::operator= (const MD5& other)
{
memcpy (result, other.result, sizeof (result));
return *this;
}
void processBlock (const void* data, size_t dataSize) noexcept
{
int bufferPos = ((count[0] >> 3) & 0x3F);
//==============================================================================
MD5::MD5 (const MemoryBlock& data)
{
ProcessContext context;
context.processBlock (data.getData(), data.getSize());
context.finish (result);
}
count[0] += (uint32) (dataSize << 3);
MD5::MD5 (const void* data, const size_t numBytes)
{
ProcessContext context;
context.processBlock (data, numBytes);
context.finish (result);
}
if (count[0] < ((uint32) dataSize << 3))
count[1]++;
MD5::MD5 (const String& text)
{
ProcessContext context;
String::CharPointerType t (text.getCharPointer());
count[1] += (uint32) (dataSize >> 29);
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());
const size_t spaceLeft = 64 - bufferPos;
size_t i = 0;
context.processBlock (&unicodeChar, sizeof (unicodeChar));
}
if (dataSize >= spaceLeft)
{
memcpy (buffer + bufferPos, data, spaceLeft);
transform (buffer);
context.finish (result);
}
for (i = spaceLeft; i + 64 <= dataSize; i += 64)
transform (static_cast <const char*> (data) + i);
void MD5::processStream (InputStream& input, int64 numBytesToRead)
{
ProcessContext context;
bufferPos = 0;
}
if (numBytesToRead < 0)
numBytesToRead = std::numeric_limits<int64>::max();
memcpy (buffer + bufferPos, static_cast <const char*> (data) + i, dataSize - i);
}
while (numBytesToRead > 0)
void transform (const void* bufferToTransform) noexcept
{ {
uint8 tempBuffer [512];
const int bytesRead = input.read (tempBuffer, (int) jmin (numBytesToRead, (int64) sizeof (tempBuffer)));
if (bytesRead <= 0)
break;
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);
}
numBytesToRead -= bytesRead;
void finish (void* result) noexcept
{
unsigned char encodedLength[8];
encode (encodedLength, count, 8);
context.processBlock (tempBuffer, bytesRead);
}
// Pad out to 56 mod 64.
const int index = (uint32) ((count[0] >> 3) & 0x3f);
context.finish (result);
}
const int paddingLength = (index < 56) ? (56 - index)
: (120 - index);
MD5::MD5 (InputStream& input, int64 numBytesToRead)
{
processStream (input, numBytesToRead);
}
uint8 paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero.
processBlock (paddingBuffer, paddingLength);
MD5::MD5 (const File& file)
{
FileInputStream fin (file);
processBlock (encodedLength, 8);
if (fin.getStatus().wasOk())
processStream (fin, -1);
else
zerostruct (result);
}
encode (result, state, 16);
zerostruct (buffer);
}
MD5::~MD5()
{
}
private:
uint8 buffer [64];
uint32 state [4];
uint32 count [2];
//==============================================================================
namespace MD5Functions
{
void encode (void* const output, const void* const input, const int numBytes) noexcept
static void encode (void* const output, const void* const input, const int numBytes) noexcept
{ {
for (int i = 0; i < (numBytes >> 2); ++i) for (int i = 0; i < (numBytes >> 2); ++i)
static_cast<uint32*> (output)[i] = ByteOrder::swapIfBigEndian (static_cast<const uint32*> (input) [i]); static_cast<uint32*> (output)[i] = ByteOrder::swapIfBigEndian (static_cast<const uint32*> (input) [i]);
} }
inline uint32 rotateLeft (const uint32 x, const uint32 n) noexcept { return (x << n) | (x >> (32 - n)); }
static 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); }
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); }
void FF (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac) noexcept
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 += F (b, c, d) + x + ac;
a = rotateLeft (a, s) + b; 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
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 += G (b, c, d) + x + ac;
a = rotateLeft (a, s) + b; 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
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 += H (b, c, d) + x + ac;
a = rotateLeft (a, s) + b; 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
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 += I (b, c, d) + x + ac;
a = rotateLeft (a, s) + b; a = rotateLeft (a, s) + b;
} }
}
};
//============================================================================== //==============================================================================
MD5::ProcessContext::ProcessContext()
MD5::MD5() noexcept
{ {
state[0] = 0x67452301;
state[1] = 0xefcdab89;
state[2] = 0x98badcfe;
state[3] = 0x10325476;
zerostruct (result);
}
count[0] = 0;
count[1] = 0;
MD5::MD5 (const MD5& other) noexcept
{
memcpy (result, other.result, sizeof (result));
} }
void MD5::ProcessContext::processBlock (const void* const data, const size_t dataSize)
MD5& MD5::operator= (const MD5& other) noexcept
{ {
int bufferPos = ((count[0] >> 3) & 0x3F);
memcpy (result, other.result, sizeof (result));
return *this;
}
count[0] += (uint32) (dataSize << 3);
//==============================================================================
MD5::MD5 (const MemoryBlock& data) noexcept
{
processData (data.getData(), data.getSize());
}
if (count[0] < ((uint32) dataSize << 3))
count[1]++;
MD5::MD5 (const void* data, const size_t numBytes) noexcept
{
processData (data, numBytes);
}
count[1] += (uint32) (dataSize >> 29);
MD5::MD5 (const CharPointer_UTF8& utf8) noexcept
{
jassert (utf8.getAddress() != nullptr);
processData (utf8.getAddress(), utf8.sizeInBytes() - 1);
}
const size_t spaceLeft = 64 - bufferPos;
size_t i = 0;
MD5 MD5::fromUTF32 (const String& text)
{
MD5Generator generator;
String::CharPointerType t (text.getCharPointer());
if (dataSize >= spaceLeft)
while (! t.isEmpty())
{ {
memcpy (buffer + bufferPos, data, spaceLeft);
transform (buffer);
for (i = spaceLeft; i + 64 <= dataSize; i += 64)
transform (static_cast <const char*> (data) + i);
bufferPos = 0;
uint32 unicodeChar = ByteOrder::swapIfBigEndian ((uint32) t.getAndAdvance());
generator.processBlock (&unicodeChar, sizeof (unicodeChar));
} }
memcpy (buffer + bufferPos, static_cast <const char*> (data) + i, dataSize - i);
MD5 m;
generator.finish (m.result);
return m;
} }
//==============================================================================
void MD5::ProcessContext::finish (void* const result)
MD5::MD5 (InputStream& input, int64 numBytesToRead)
{ {
unsigned char encodedLength[8];
MD5Functions::encode (encodedLength, count, 8);
// Pad out to 56 mod 64.
const int index = (uint32) ((count[0] >> 3) & 0x3f);
processStream (input, numBytesToRead);
}
const int paddingLength = (index < 56) ? (56 - index)
: (120 - index);
MD5::MD5 (const File& file)
{
FileInputStream fin (file);
uint8 paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero.
processBlock (paddingBuffer, paddingLength);
if (fin.getStatus().wasOk())
processStream (fin, -1);
else
zerostruct (result);
}
processBlock (encodedLength, 8);
MD5::~MD5() noexcept {}
MD5Functions::encode (result, state, 16);
zerostruct (buffer);
void MD5::processData (const void* data, size_t numBytes) noexcept
{
MD5Generator generator;
generator.processBlock (data, numBytes);
generator.finish (result);
} }
void MD5::ProcessContext::transform (const void* const bufferToTransform)
void MD5::processStream (InputStream& input, int64 numBytesToRead)
{ {
using namespace MD5Functions;
uint32 a = state[0];
uint32 b = state[1];
uint32 c = state[2];
uint32 d = state[3];
uint32 x[16];
MD5Generator generator;
encode (x, bufferToTransform, 64);
if (numBytesToRead < 0)
numBytesToRead = std::numeric_limits<int64>::max();
enum Constants
while (numBytesToRead > 0)
{ {
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);
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);
}
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 END_JUCE_NAMESPACE

+ 26
- 36
modules/juce_cryptography/hashing/juce_MD5.h View File

@@ -41,30 +41,20 @@ class JUCE_API MD5
public: public:
//============================================================================== //==============================================================================
/** Creates a null MD5 object. */ /** Creates a null MD5 object. */
MD5();
MD5() noexcept;
/** Creates a copy of another MD5. */ /** Creates a copy of another MD5. */
MD5 (const MD5& other);
MD5 (const MD5& other) noexcept;
/** Copies another MD5. */ /** Copies another MD5. */
MD5& operator= (const MD5& other);
MD5& operator= (const MD5& other) noexcept;
//============================================================================== //==============================================================================
/** Creates a checksum for a block of binary data. */ /** 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. */ /** 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. /** Creates a checksum for the input from a stream.
@@ -77,46 +67,46 @@ public:
/** Creates a checksum for a file. */ /** Creates a checksum for a file. */
explicit MD5 (const File& 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. */ /** Destructor. */
~MD5();
~MD5() noexcept;
//============================================================================== //==============================================================================
/** Returns the checksum as a 16-byte block of data. */ /** Returns the checksum as a 16-byte block of data. */
MemoryBlock getRawChecksumData() const; MemoryBlock getRawChecksumData() const;
/** Returns a pointer to the 16-byte array of result data. */ /** 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. */ /** Returns the checksum as a 32-digit hex string. */
String toHexString() const; String toHexString() const;
/** Creates an MD5 from a little-endian UTF-32 encoded string.
//==============================================================================
/** Compares this to another MD5. */
bool operator== (const MD5& other) const;
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;
//==============================================================================
bool operator== (const MD5&) const noexcept;
bool operator!= (const MD5&) const noexcept;
private: private:
//============================================================================== //==============================================================================
uint8 result [16]; 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); JUCE_LEAK_DETECTOR (MD5);
}; };


+ 4
- 4
modules/juce_cryptography/hashing/juce_SHA256.cpp View File

@@ -156,19 +156,19 @@ private:
}; };
//============================================================================== //==============================================================================
SHA256::SHA256()
SHA256::SHA256() noexcept
{ {
zerostruct (result); zerostruct (result);
} }
SHA256::~SHA256() {}
SHA256::~SHA256() noexcept {}
SHA256::SHA256 (const SHA256& other)
SHA256::SHA256 (const SHA256& other) noexcept
{ {
memcpy (result, other.result, sizeof (result)); 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)); memcpy (result, other.result, sizeof (result));
return *this; return *this;


+ 6
- 6
modules/juce_cryptography/hashing/juce_SHA256.h View File

@@ -45,16 +45,16 @@ public:
The default constructor just creates a hash filled with zeros. (This is not The default constructor just creates a hash filled with zeros. (This is not
equal to the hash of an empty block of data). equal to the hash of an empty block of data).
*/ */
SHA256();
SHA256() noexcept;
/** Destructor. */ /** Destructor. */
~SHA256();
~SHA256() noexcept;
/** Creates a copy of another SHA256. */ /** Creates a copy of another SHA256. */
SHA256 (const SHA256& other);
SHA256 (const SHA256& other) noexcept;
/** Copies another SHA256. */ /** Copies another SHA256. */
SHA256& operator= (const SHA256& other);
SHA256& operator= (const SHA256& other) noexcept;
//============================================================================== //==============================================================================
/** Creates a hash from a block of raw data. */ /** Creates a hash from a block of raw data. */
@@ -85,8 +85,8 @@ public:
String toHexString() const; 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: private:


Write Preview
Loading…
Cancel
Save