migrating to the latest JUCE version
This commit is contained in:
Nikolai Rodionov
@ -1,308 +1,308 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
struct MD5Generator
|
||||
{
|
||||
void processBlock (const void* data, size_t dataSize) noexcept
|
||||
{
|
||||
auto bufferPos = ((count[0] >> 3) & 0x3f);
|
||||
|
||||
count[0] += (uint32_t) (dataSize << 3);
|
||||
|
||||
if (count[0] < ((uint32_t) dataSize << 3))
|
||||
count[1]++;
|
||||
|
||||
count[1] += (uint32_t) (dataSize >> 29);
|
||||
|
||||
auto spaceLeft = (size_t) 64 - (size_t) 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<const char*> (data) + i);
|
||||
|
||||
bufferPos = 0;
|
||||
}
|
||||
|
||||
memcpy (buffer + bufferPos, static_cast<const char*> (data) + i, dataSize - i);
|
||||
}
|
||||
|
||||
void transform (const void* bufferToTransform) noexcept
|
||||
{
|
||||
auto a = state[0];
|
||||
auto b = state[1];
|
||||
auto c = state[2];
|
||||
auto d = state[3];
|
||||
|
||||
uint32_t x[16];
|
||||
copyWithEndiannessConversion (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;
|
||||
}
|
||||
|
||||
void finish (uint8_t* result) noexcept
|
||||
{
|
||||
uint8_t encodedLength[8];
|
||||
copyWithEndiannessConversion (encodedLength, count, 8);
|
||||
|
||||
// Pad out to 56 mod 64.
|
||||
auto index = (count[0] >> 3) & 0x3f;
|
||||
auto paddingLength = (index < 56 ? 56 : 120) - index;
|
||||
|
||||
uint8_t paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero.
|
||||
|
||||
processBlock (paddingBuffer, (size_t) paddingLength);
|
||||
processBlock (encodedLength, 8);
|
||||
|
||||
copyWithEndiannessConversion (result, state, 16);
|
||||
}
|
||||
|
||||
private:
|
||||
uint8_t buffer[64] = {};
|
||||
uint32_t state[4] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
|
||||
uint32_t count[2] = {};
|
||||
|
||||
static void copyWithEndiannessConversion (void* output, const void* input, size_t numBytes) noexcept
|
||||
{
|
||||
#if JUCE_LITTLE_ENDIAN
|
||||
memcpy (output, input, numBytes);
|
||||
#else
|
||||
auto dst = static_cast<uint8_t*> (output);
|
||||
auto src = static_cast<const uint8_t*> (input);
|
||||
|
||||
for (size_t i = 0; i < numBytes; i += 4)
|
||||
{
|
||||
dst[i + 0] = src[i + 3];
|
||||
dst[i + 1] = src[i + 2];
|
||||
dst[i + 2] = src[i + 1];
|
||||
dst[i + 3] = src[i + 0];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static uint32_t rotateLeft (uint32_t x, uint32_t n) noexcept { return (x << n) | (x >> (32 - n)); }
|
||||
|
||||
static uint32_t F (uint32_t x, uint32_t y, uint32_t z) noexcept { return (x & y) | (~x & z); }
|
||||
static uint32_t G (uint32_t x, uint32_t y, uint32_t z) noexcept { return (x & z) | (y & ~z); }
|
||||
static uint32_t H (uint32_t x, uint32_t y, uint32_t z) noexcept { return x ^ y ^ z; }
|
||||
static uint32_t I (uint32_t x, uint32_t y, uint32_t z) noexcept { return y ^ (x | ~z); }
|
||||
|
||||
static void FF (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + F (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void GG (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + G (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void HH (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + H (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void II (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + I (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
MD5::MD5() = default;
|
||||
MD5::~MD5() = default;
|
||||
MD5::MD5 (const MD5&) = default;
|
||||
MD5& MD5::operator= (const MD5&) = default;
|
||||
|
||||
MD5::MD5 (const void* data, size_t numBytes) noexcept
|
||||
{
|
||||
MD5Generator generator;
|
||||
generator.processBlock (data, numBytes);
|
||||
generator.finish (result);
|
||||
}
|
||||
|
||||
MD5::MD5 (const MemoryBlock& data) noexcept : MD5 (data.getData(), data.getSize()) {}
|
||||
MD5::MD5 (CharPointer_UTF8 utf8) noexcept : MD5 (utf8.getAddress(), utf8.getAddress() != nullptr ? utf8.sizeInBytes() - 1 : 0) {}
|
||||
|
||||
MD5 MD5::fromUTF32 (StringRef text)
|
||||
{
|
||||
MD5 m;
|
||||
MD5Generator generator;
|
||||
|
||||
for (auto t = text.text; t.isNotEmpty();)
|
||||
{
|
||||
auto unicodeChar = ByteOrder::swapIfBigEndian ((uint32_t) t.getAndAdvance());
|
||||
generator.processBlock (&unicodeChar, sizeof (unicodeChar));
|
||||
}
|
||||
|
||||
generator.finish (m.result);
|
||||
return m;
|
||||
}
|
||||
|
||||
MD5::MD5 (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
processStream (input, numBytesToRead);
|
||||
}
|
||||
|
||||
MD5::MD5 (const File& file)
|
||||
{
|
||||
FileInputStream fin (file);
|
||||
|
||||
if (fin.openedOk())
|
||||
processStream (fin, -1);
|
||||
}
|
||||
|
||||
void MD5::processStream (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
MD5Generator generator;
|
||||
|
||||
if (numBytesToRead < 0)
|
||||
numBytesToRead = std::numeric_limits<int64>::max();
|
||||
|
||||
while (numBytesToRead > 0)
|
||||
{
|
||||
uint8_t tempBuffer[512];
|
||||
auto bytesRead = input.read (tempBuffer, (int) jmin (numBytesToRead, (int64) sizeof (tempBuffer)));
|
||||
|
||||
if (bytesRead <= 0)
|
||||
break;
|
||||
|
||||
numBytesToRead -= bytesRead;
|
||||
generator.processBlock (tempBuffer, (size_t) bytesRead);
|
||||
}
|
||||
|
||||
generator.finish (result);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
MemoryBlock MD5::getRawChecksumData() const
|
||||
{
|
||||
return MemoryBlock (result, sizeof (result));
|
||||
}
|
||||
|
||||
String MD5::toHexString() const
|
||||
{
|
||||
return String::toHexString (result, sizeof (result), 0);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
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); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
//==============================================================================
|
||||
#if JUCE_UNIT_TESTS
|
||||
|
||||
class MD5Tests : public UnitTest
|
||||
{
|
||||
public:
|
||||
MD5Tests()
|
||||
: UnitTest ("MD5", UnitTestCategories::cryptography)
|
||||
{}
|
||||
|
||||
void test (const char* input, const char* expected)
|
||||
{
|
||||
{
|
||||
MD5 hash (input, strlen (input));
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
MemoryInputStream m (input, strlen (input), false);
|
||||
MD5 hash (m);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
}
|
||||
|
||||
void runTest() override
|
||||
{
|
||||
beginTest ("MD5");
|
||||
|
||||
test ("", "d41d8cd98f00b204e9800998ecf8427e");
|
||||
test ("The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6");
|
||||
test ("The quick brown fox jumps over the lazy dog.", "e4d909c290d0fb1ca068ffaddf22cbd0");
|
||||
|
||||
expectEquals (MD5 (CharPointer_UTF8(nullptr)).toHexString(), String ("d41d8cd98f00b204e9800998ecf8427e"));
|
||||
}
|
||||
};
|
||||
|
||||
static MD5Tests MD5UnitTests;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2022 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
|
||||
Agreement and JUCE Privacy Policy.
|
||||
|
||||
End User License Agreement: www.juce.com/juce-7-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
struct MD5Generator
|
||||
{
|
||||
void processBlock (const void* data, size_t dataSize) noexcept
|
||||
{
|
||||
auto bufferPos = ((count[0] >> 3) & 0x3f);
|
||||
|
||||
count[0] += (uint32_t) (dataSize << 3);
|
||||
|
||||
if (count[0] < ((uint32_t) dataSize << 3))
|
||||
count[1]++;
|
||||
|
||||
count[1] += (uint32_t) (dataSize >> 29);
|
||||
|
||||
auto spaceLeft = (size_t) 64 - (size_t) 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<const char*> (data) + i);
|
||||
|
||||
bufferPos = 0;
|
||||
}
|
||||
|
||||
memcpy (buffer + bufferPos, static_cast<const char*> (data) + i, dataSize - i);
|
||||
}
|
||||
|
||||
void transform (const void* bufferToTransform) noexcept
|
||||
{
|
||||
auto a = state[0];
|
||||
auto b = state[1];
|
||||
auto c = state[2];
|
||||
auto d = state[3];
|
||||
|
||||
uint32_t x[16];
|
||||
copyWithEndiannessConversion (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;
|
||||
}
|
||||
|
||||
void finish (uint8_t* result) noexcept
|
||||
{
|
||||
uint8_t encodedLength[8];
|
||||
copyWithEndiannessConversion (encodedLength, count, 8);
|
||||
|
||||
// Pad out to 56 mod 64.
|
||||
auto index = (count[0] >> 3) & 0x3f;
|
||||
auto paddingLength = (index < 56 ? 56 : 120) - index;
|
||||
|
||||
uint8_t paddingBuffer[64] = { 0x80 }; // first byte is 0x80, remaining bytes are zero.
|
||||
|
||||
processBlock (paddingBuffer, (size_t) paddingLength);
|
||||
processBlock (encodedLength, 8);
|
||||
|
||||
copyWithEndiannessConversion (result, state, 16);
|
||||
}
|
||||
|
||||
private:
|
||||
uint8_t buffer[64] = {};
|
||||
uint32_t state[4] = { 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 };
|
||||
uint32_t count[2] = {};
|
||||
|
||||
static void copyWithEndiannessConversion (void* output, const void* input, size_t numBytes) noexcept
|
||||
{
|
||||
#if JUCE_LITTLE_ENDIAN
|
||||
memcpy (output, input, numBytes);
|
||||
#else
|
||||
auto dst = static_cast<uint8_t*> (output);
|
||||
auto src = static_cast<const uint8_t*> (input);
|
||||
|
||||
for (size_t i = 0; i < numBytes; i += 4)
|
||||
{
|
||||
dst[i + 0] = src[i + 3];
|
||||
dst[i + 1] = src[i + 2];
|
||||
dst[i + 2] = src[i + 1];
|
||||
dst[i + 3] = src[i + 0];
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
static uint32_t rotateLeft (uint32_t x, uint32_t n) noexcept { return (x << n) | (x >> (32 - n)); }
|
||||
|
||||
static uint32_t F (uint32_t x, uint32_t y, uint32_t z) noexcept { return (x & y) | (~x & z); }
|
||||
static uint32_t G (uint32_t x, uint32_t y, uint32_t z) noexcept { return (x & z) | (y & ~z); }
|
||||
static uint32_t H (uint32_t x, uint32_t y, uint32_t z) noexcept { return x ^ y ^ z; }
|
||||
static uint32_t I (uint32_t x, uint32_t y, uint32_t z) noexcept { return y ^ (x | ~z); }
|
||||
|
||||
static void FF (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + F (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void GG (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + G (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void HH (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + H (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
|
||||
static void II (uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac) noexcept
|
||||
{
|
||||
a = rotateLeft (a + I (b, c, d) + x + ac, s) + b;
|
||||
}
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
MD5::MD5() = default;
|
||||
MD5::~MD5() = default;
|
||||
MD5::MD5 (const MD5&) = default;
|
||||
MD5& MD5::operator= (const MD5&) = default;
|
||||
|
||||
MD5::MD5 (const void* data, size_t numBytes) noexcept
|
||||
{
|
||||
MD5Generator generator;
|
||||
generator.processBlock (data, numBytes);
|
||||
generator.finish (result);
|
||||
}
|
||||
|
||||
MD5::MD5 (const MemoryBlock& data) noexcept : MD5 (data.getData(), data.getSize()) {}
|
||||
MD5::MD5 (CharPointer_UTF8 utf8) noexcept : MD5 (utf8.getAddress(), utf8.getAddress() != nullptr ? utf8.sizeInBytes() - 1 : 0) {}
|
||||
|
||||
MD5 MD5::fromUTF32 (StringRef text)
|
||||
{
|
||||
MD5 m;
|
||||
MD5Generator generator;
|
||||
|
||||
for (auto t = text.text; t.isNotEmpty();)
|
||||
{
|
||||
auto unicodeChar = ByteOrder::swapIfBigEndian ((uint32_t) t.getAndAdvance());
|
||||
generator.processBlock (&unicodeChar, sizeof (unicodeChar));
|
||||
}
|
||||
|
||||
generator.finish (m.result);
|
||||
return m;
|
||||
}
|
||||
|
||||
MD5::MD5 (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
processStream (input, numBytesToRead);
|
||||
}
|
||||
|
||||
MD5::MD5 (const File& file)
|
||||
{
|
||||
FileInputStream fin (file);
|
||||
|
||||
if (fin.openedOk())
|
||||
processStream (fin, -1);
|
||||
}
|
||||
|
||||
void MD5::processStream (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
MD5Generator generator;
|
||||
|
||||
if (numBytesToRead < 0)
|
||||
numBytesToRead = std::numeric_limits<int64>::max();
|
||||
|
||||
while (numBytesToRead > 0)
|
||||
{
|
||||
uint8_t tempBuffer[512];
|
||||
auto bytesRead = input.read (tempBuffer, (int) jmin (numBytesToRead, (int64) sizeof (tempBuffer)));
|
||||
|
||||
if (bytesRead <= 0)
|
||||
break;
|
||||
|
||||
numBytesToRead -= bytesRead;
|
||||
generator.processBlock (tempBuffer, (size_t) bytesRead);
|
||||
}
|
||||
|
||||
generator.finish (result);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
MemoryBlock MD5::getRawChecksumData() const
|
||||
{
|
||||
return MemoryBlock (result, sizeof (result));
|
||||
}
|
||||
|
||||
String MD5::toHexString() const
|
||||
{
|
||||
return String::toHexString (result, sizeof (result), 0);
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
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); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
//==============================================================================
|
||||
#if JUCE_UNIT_TESTS
|
||||
|
||||
class MD5Tests : public UnitTest
|
||||
{
|
||||
public:
|
||||
MD5Tests()
|
||||
: UnitTest ("MD5", UnitTestCategories::cryptography)
|
||||
{}
|
||||
|
||||
void test (const char* input, const char* expected)
|
||||
{
|
||||
{
|
||||
MD5 hash (input, strlen (input));
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
MemoryInputStream m (input, strlen (input), false);
|
||||
MD5 hash (m);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
}
|
||||
|
||||
void runTest() override
|
||||
{
|
||||
beginTest ("MD5");
|
||||
|
||||
test ("", "d41d8cd98f00b204e9800998ecf8427e");
|
||||
test ("The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6");
|
||||
test ("The quick brown fox jumps over the lazy dog.", "e4d909c290d0fb1ca068ffaddf22cbd0");
|
||||
|
||||
expectEquals (MD5 (CharPointer_UTF8(nullptr)).toHexString(), String ("d41d8cd98f00b204e9800998ecf8427e"));
|
||||
}
|
||||
};
|
||||
|
||||
static MD5Tests MD5UnitTests;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
|
||||
@ -1,119 +1,119 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
MD5 checksum class.
|
||||
|
||||
Create one of these with a block of source data or a stream, and it calculates
|
||||
the MD5 checksum of that data.
|
||||
|
||||
You can then retrieve this checksum as a 16-byte block, or as a hex string.
|
||||
@see SHA256
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API MD5
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a null MD5 object. */
|
||||
MD5();
|
||||
|
||||
/** Creates a copy of another MD5. */
|
||||
MD5 (const MD5&);
|
||||
|
||||
/** Copies another MD5. */
|
||||
MD5& operator= (const MD5&);
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a checksum for a block of binary data. */
|
||||
explicit MD5 (const MemoryBlock&) noexcept;
|
||||
|
||||
/** Creates a checksum for a block of binary data. */
|
||||
MD5 (const void* data, size_t numBytes) noexcept;
|
||||
|
||||
/** Creates a checksum for the input from a stream.
|
||||
|
||||
This will read up to the given number of bytes from the stream, and produce the
|
||||
checksum of that. If the number of bytes to read is negative, it'll read
|
||||
until the stream is exhausted.
|
||||
*/
|
||||
MD5 (InputStream& input, int64 numBytesToRead = -1);
|
||||
|
||||
/** Creates a checksum for the contents of a file. */
|
||||
explicit MD5 (const File&);
|
||||
|
||||
/** Creates a checksum of the characters in a UTF-8 buffer.
|
||||
E.g.
|
||||
@code MD5 checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit MD5 (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
/** Destructor. */
|
||||
~MD5();
|
||||
|
||||
//==============================================================================
|
||||
/** 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; }
|
||||
|
||||
/** 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 (StringRef);
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const MD5&) const noexcept;
|
||||
bool operator!= (const MD5&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result[16] = {};
|
||||
|
||||
void processStream (InputStream&, int64);
|
||||
|
||||
// This private constructor is declared here to prevent you accidentally passing a
|
||||
// String and having it unexpectedly call the constructor that takes a File.
|
||||
explicit MD5 (const String&) = delete;
|
||||
|
||||
JUCE_LEAK_DETECTOR (MD5)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2022 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
|
||||
Agreement and JUCE Privacy Policy.
|
||||
|
||||
End User License Agreement: www.juce.com/juce-7-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
MD5 checksum class.
|
||||
|
||||
Create one of these with a block of source data or a stream, and it calculates
|
||||
the MD5 checksum of that data.
|
||||
|
||||
You can then retrieve this checksum as a 16-byte block, or as a hex string.
|
||||
@see SHA256
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API MD5
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a null MD5 object. */
|
||||
MD5();
|
||||
|
||||
/** Creates a copy of another MD5. */
|
||||
MD5 (const MD5&);
|
||||
|
||||
/** Copies another MD5. */
|
||||
MD5& operator= (const MD5&);
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a checksum for a block of binary data. */
|
||||
explicit MD5 (const MemoryBlock&) noexcept;
|
||||
|
||||
/** Creates a checksum for a block of binary data. */
|
||||
MD5 (const void* data, size_t numBytes) noexcept;
|
||||
|
||||
/** Creates a checksum for the input from a stream.
|
||||
|
||||
This will read up to the given number of bytes from the stream, and produce the
|
||||
checksum of that. If the number of bytes to read is negative, it'll read
|
||||
until the stream is exhausted.
|
||||
*/
|
||||
MD5 (InputStream& input, int64 numBytesToRead = -1);
|
||||
|
||||
/** Creates a checksum for the contents of a file. */
|
||||
explicit MD5 (const File&);
|
||||
|
||||
/** Creates a checksum of the characters in a UTF-8 buffer.
|
||||
E.g.
|
||||
@code MD5 checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit MD5 (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
/** Destructor. */
|
||||
~MD5();
|
||||
|
||||
//==============================================================================
|
||||
/** 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; }
|
||||
|
||||
/** 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 (StringRef);
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const MD5&) const noexcept;
|
||||
bool operator!= (const MD5&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result[16] = {};
|
||||
|
||||
void processStream (InputStream&, int64);
|
||||
|
||||
// This private constructor is declared here to prevent you accidentally passing a
|
||||
// String and having it unexpectedly call the constructor that takes a File.
|
||||
explicit MD5 (const String&) = delete;
|
||||
|
||||
JUCE_LEAK_DETECTOR (MD5)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
|
||||
@ -1,259 +1,259 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
struct SHA256Processor
|
||||
{
|
||||
// expects 64 bytes of data
|
||||
void processFullBlock (const void* data) noexcept
|
||||
{
|
||||
const uint32_t constants[] =
|
||||
{
|
||||
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
|
||||
};
|
||||
|
||||
uint32_t block[16], s[8];
|
||||
memcpy (s, state, sizeof (s));
|
||||
|
||||
auto d = static_cast<const uint8_t*> (data);
|
||||
|
||||
for (auto& b : block)
|
||||
{
|
||||
b = (uint32_t (d[0]) << 24) | (uint32_t (d[1]) << 16) | (uint32_t (d[2]) << 8) | d[3];
|
||||
d += 4;
|
||||
}
|
||||
|
||||
auto convolve = [&] (uint32_t i, uint32_t j)
|
||||
{
|
||||
s[(7 - i) & 7] += S1 (s[(4 - i) & 7]) + ch (s[(4 - i) & 7], s[(5 - i) & 7], s[(6 - i) & 7]) + constants[i + j]
|
||||
+ (j != 0 ? (block[i & 15] += s1 (block[(i - 2) & 15]) + block[(i - 7) & 15] + s0 (block[(i - 15) & 15]))
|
||||
: block[i]);
|
||||
s[(3 - i) & 7] += s[(7 - i) & 7];
|
||||
s[(7 - i) & 7] += S0 (s[(0 - i) & 7]) + maj (s[(0 - i) & 7], s[(1 - i) & 7], s[(2 - i) & 7]);
|
||||
};
|
||||
|
||||
for (uint32_t j = 0; j < 64; j += 16)
|
||||
for (uint32_t i = 0; i < 16; ++i)
|
||||
convolve (i, j);
|
||||
|
||||
for (int i = 0; i < 8; ++i)
|
||||
state[i] += s[i];
|
||||
|
||||
length += 64;
|
||||
}
|
||||
|
||||
void processFinalBlock (const void* data, uint32_t numBytes) noexcept
|
||||
{
|
||||
jassert (numBytes < 64);
|
||||
|
||||
length += numBytes;
|
||||
length *= 8; // (the length is stored as a count of bits, not bytes)
|
||||
|
||||
uint8_t finalBlocks[128];
|
||||
|
||||
memcpy (finalBlocks, data, numBytes);
|
||||
finalBlocks[numBytes++] = 128; // append a '1' bit
|
||||
|
||||
while (numBytes != 56 && numBytes < 64 + 56)
|
||||
finalBlocks[numBytes++] = 0; // pad with zeros..
|
||||
|
||||
for (int i = 8; --i >= 0;)
|
||||
finalBlocks[numBytes++] = (uint8_t) (length >> (i * 8)); // append the length.
|
||||
|
||||
jassert (numBytes == 64 || numBytes == 128);
|
||||
|
||||
processFullBlock (finalBlocks);
|
||||
|
||||
if (numBytes > 64)
|
||||
processFullBlock (finalBlocks + 64);
|
||||
}
|
||||
|
||||
void copyResult (uint8_t* result) const noexcept
|
||||
{
|
||||
for (auto s : state)
|
||||
{
|
||||
*result++ = (uint8_t) (s >> 24);
|
||||
*result++ = (uint8_t) (s >> 16);
|
||||
*result++ = (uint8_t) (s >> 8);
|
||||
*result++ = (uint8_t) s;
|
||||
}
|
||||
}
|
||||
|
||||
void processStream (InputStream& input, int64_t numBytesToRead, uint8_t* result)
|
||||
{
|
||||
if (numBytesToRead < 0)
|
||||
numBytesToRead = std::numeric_limits<int64_t>::max();
|
||||
|
||||
for (;;)
|
||||
{
|
||||
uint8_t buffer[64];
|
||||
auto bytesRead = input.read (buffer, (int) jmin (numBytesToRead, (int64_t) sizeof (buffer)));
|
||||
|
||||
if (bytesRead < (int) sizeof (buffer))
|
||||
{
|
||||
processFinalBlock (buffer, (unsigned int) bytesRead);
|
||||
break;
|
||||
}
|
||||
|
||||
numBytesToRead -= (int64_t) sizeof (buffer);
|
||||
processFullBlock (buffer);
|
||||
}
|
||||
|
||||
copyResult (result);
|
||||
}
|
||||
|
||||
private:
|
||||
uint32_t state[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
||||
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
|
||||
uint64_t length = 0;
|
||||
|
||||
static uint32_t rotate (uint32_t x, uint32_t y) noexcept { return (x >> y) | (x << (32 - y)); }
|
||||
static uint32_t ch (uint32_t x, uint32_t y, uint32_t z) noexcept { return z ^ ((y ^ z) & x); }
|
||||
static uint32_t maj (uint32_t x, uint32_t y, uint32_t z) noexcept { return y ^ ((y ^ z) & (x ^ y)); }
|
||||
|
||||
static uint32_t s0 (uint32_t x) noexcept { return rotate (x, 7) ^ rotate (x, 18) ^ (x >> 3); }
|
||||
static uint32_t s1 (uint32_t x) noexcept { return rotate (x, 17) ^ rotate (x, 19) ^ (x >> 10); }
|
||||
static uint32_t S0 (uint32_t x) noexcept { return rotate (x, 2) ^ rotate (x, 13) ^ rotate (x, 22); }
|
||||
static uint32_t S1 (uint32_t x) noexcept { return rotate (x, 6) ^ rotate (x, 11) ^ rotate (x, 25); }
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
SHA256::SHA256() = default;
|
||||
SHA256::~SHA256() = default;
|
||||
SHA256::SHA256 (const SHA256&) = default;
|
||||
SHA256& SHA256::operator= (const SHA256&) = default;
|
||||
|
||||
SHA256::SHA256 (const MemoryBlock& data)
|
||||
{
|
||||
process (data.getData(), data.getSize());
|
||||
}
|
||||
|
||||
SHA256::SHA256 (const void* data, size_t numBytes)
|
||||
{
|
||||
process (data, numBytes);
|
||||
}
|
||||
|
||||
SHA256::SHA256 (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
SHA256Processor processor;
|
||||
processor.processStream (input, numBytesToRead, result);
|
||||
}
|
||||
|
||||
SHA256::SHA256 (const File& file)
|
||||
{
|
||||
FileInputStream fin (file);
|
||||
|
||||
if (fin.getStatus().wasOk())
|
||||
{
|
||||
SHA256Processor processor;
|
||||
processor.processStream (fin, -1, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
zerostruct (result);
|
||||
}
|
||||
}
|
||||
|
||||
SHA256::SHA256 (CharPointer_UTF8 utf8) noexcept
|
||||
{
|
||||
jassert (utf8.getAddress() != nullptr);
|
||||
process (utf8.getAddress(), utf8.sizeInBytes() - 1);
|
||||
}
|
||||
|
||||
void SHA256::process (const void* data, size_t numBytes)
|
||||
{
|
||||
MemoryInputStream m (data, numBytes, false);
|
||||
SHA256Processor processor;
|
||||
processor.processStream (m, -1, result);
|
||||
}
|
||||
|
||||
MemoryBlock SHA256::getRawData() const
|
||||
{
|
||||
return MemoryBlock (result, sizeof (result));
|
||||
}
|
||||
|
||||
String SHA256::toHexString() const
|
||||
{
|
||||
return String::toHexString (result, sizeof (result), 0);
|
||||
}
|
||||
|
||||
bool SHA256::operator== (const SHA256& other) const noexcept { return memcmp (result, other.result, sizeof (result)) == 0; }
|
||||
bool SHA256::operator!= (const SHA256& other) const noexcept { return ! operator== (other); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
#if JUCE_UNIT_TESTS
|
||||
|
||||
class SHA256Tests : public UnitTest
|
||||
{
|
||||
public:
|
||||
SHA256Tests()
|
||||
: UnitTest ("SHA-256", UnitTestCategories::cryptography)
|
||||
{}
|
||||
|
||||
void test (const char* input, const char* expected)
|
||||
{
|
||||
{
|
||||
SHA256 hash (input, strlen (input));
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
CharPointer_UTF8 utf8 (input);
|
||||
SHA256 hash (utf8);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
MemoryInputStream m (input, strlen (input), false);
|
||||
SHA256 hash (m);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
}
|
||||
|
||||
void runTest() override
|
||||
{
|
||||
beginTest ("SHA256");
|
||||
|
||||
test ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
|
||||
test ("The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
|
||||
test ("The quick brown fox jumps over the lazy dog.", "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c");
|
||||
}
|
||||
};
|
||||
|
||||
static SHA256Tests sha256UnitTests;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2022 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
|
||||
Agreement and JUCE Privacy Policy.
|
||||
|
||||
End User License Agreement: www.juce.com/juce-7-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
struct SHA256Processor
|
||||
{
|
||||
// expects 64 bytes of data
|
||||
void processFullBlock (const void* data) noexcept
|
||||
{
|
||||
const uint32_t constants[] =
|
||||
{
|
||||
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
|
||||
};
|
||||
|
||||
uint32_t block[16], s[8];
|
||||
memcpy (s, state, sizeof (s));
|
||||
|
||||
auto d = static_cast<const uint8_t*> (data);
|
||||
|
||||
for (auto& b : block)
|
||||
{
|
||||
b = (uint32_t (d[0]) << 24) | (uint32_t (d[1]) << 16) | (uint32_t (d[2]) << 8) | d[3];
|
||||
d += 4;
|
||||
}
|
||||
|
||||
auto convolve = [&] (uint32_t i, uint32_t j)
|
||||
{
|
||||
s[(7 - i) & 7] += S1 (s[(4 - i) & 7]) + ch (s[(4 - i) & 7], s[(5 - i) & 7], s[(6 - i) & 7]) + constants[i + j]
|
||||
+ (j != 0 ? (block[i & 15] += s1 (block[(i - 2) & 15]) + block[(i - 7) & 15] + s0 (block[(i - 15) & 15]))
|
||||
: block[i]);
|
||||
s[(3 - i) & 7] += s[(7 - i) & 7];
|
||||
s[(7 - i) & 7] += S0 (s[(0 - i) & 7]) + maj (s[(0 - i) & 7], s[(1 - i) & 7], s[(2 - i) & 7]);
|
||||
};
|
||||
|
||||
for (uint32_t j = 0; j < 64; j += 16)
|
||||
for (uint32_t i = 0; i < 16; ++i)
|
||||
convolve (i, j);
|
||||
|
||||
for (int i = 0; i < 8; ++i)
|
||||
state[i] += s[i];
|
||||
|
||||
length += 64;
|
||||
}
|
||||
|
||||
void processFinalBlock (const void* data, uint32_t numBytes) noexcept
|
||||
{
|
||||
jassert (numBytes < 64);
|
||||
|
||||
length += numBytes;
|
||||
length *= 8; // (the length is stored as a count of bits, not bytes)
|
||||
|
||||
uint8_t finalBlocks[128];
|
||||
|
||||
memcpy (finalBlocks, data, numBytes);
|
||||
finalBlocks[numBytes++] = 128; // append a '1' bit
|
||||
|
||||
while (numBytes != 56 && numBytes < 64 + 56)
|
||||
finalBlocks[numBytes++] = 0; // pad with zeros..
|
||||
|
||||
for (int i = 8; --i >= 0;)
|
||||
finalBlocks[numBytes++] = (uint8_t) (length >> (i * 8)); // append the length.
|
||||
|
||||
jassert (numBytes == 64 || numBytes == 128);
|
||||
|
||||
processFullBlock (finalBlocks);
|
||||
|
||||
if (numBytes > 64)
|
||||
processFullBlock (finalBlocks + 64);
|
||||
}
|
||||
|
||||
void copyResult (uint8_t* result) const noexcept
|
||||
{
|
||||
for (auto s : state)
|
||||
{
|
||||
*result++ = (uint8_t) (s >> 24);
|
||||
*result++ = (uint8_t) (s >> 16);
|
||||
*result++ = (uint8_t) (s >> 8);
|
||||
*result++ = (uint8_t) s;
|
||||
}
|
||||
}
|
||||
|
||||
void processStream (InputStream& input, int64_t numBytesToRead, uint8_t* result)
|
||||
{
|
||||
if (numBytesToRead < 0)
|
||||
numBytesToRead = std::numeric_limits<int64_t>::max();
|
||||
|
||||
for (;;)
|
||||
{
|
||||
uint8_t buffer[64];
|
||||
auto bytesRead = input.read (buffer, (int) jmin (numBytesToRead, (int64_t) sizeof (buffer)));
|
||||
|
||||
if (bytesRead < (int) sizeof (buffer))
|
||||
{
|
||||
processFinalBlock (buffer, (unsigned int) bytesRead);
|
||||
break;
|
||||
}
|
||||
|
||||
numBytesToRead -= (int64_t) sizeof (buffer);
|
||||
processFullBlock (buffer);
|
||||
}
|
||||
|
||||
copyResult (result);
|
||||
}
|
||||
|
||||
private:
|
||||
uint32_t state[8] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
|
||||
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 };
|
||||
uint64_t length = 0;
|
||||
|
||||
static uint32_t rotate (uint32_t x, uint32_t y) noexcept { return (x >> y) | (x << (32 - y)); }
|
||||
static uint32_t ch (uint32_t x, uint32_t y, uint32_t z) noexcept { return z ^ ((y ^ z) & x); }
|
||||
static uint32_t maj (uint32_t x, uint32_t y, uint32_t z) noexcept { return y ^ ((y ^ z) & (x ^ y)); }
|
||||
|
||||
static uint32_t s0 (uint32_t x) noexcept { return rotate (x, 7) ^ rotate (x, 18) ^ (x >> 3); }
|
||||
static uint32_t s1 (uint32_t x) noexcept { return rotate (x, 17) ^ rotate (x, 19) ^ (x >> 10); }
|
||||
static uint32_t S0 (uint32_t x) noexcept { return rotate (x, 2) ^ rotate (x, 13) ^ rotate (x, 22); }
|
||||
static uint32_t S1 (uint32_t x) noexcept { return rotate (x, 6) ^ rotate (x, 11) ^ rotate (x, 25); }
|
||||
};
|
||||
|
||||
//==============================================================================
|
||||
SHA256::SHA256() = default;
|
||||
SHA256::~SHA256() = default;
|
||||
SHA256::SHA256 (const SHA256&) = default;
|
||||
SHA256& SHA256::operator= (const SHA256&) = default;
|
||||
|
||||
SHA256::SHA256 (const MemoryBlock& data)
|
||||
{
|
||||
process (data.getData(), data.getSize());
|
||||
}
|
||||
|
||||
SHA256::SHA256 (const void* data, size_t numBytes)
|
||||
{
|
||||
process (data, numBytes);
|
||||
}
|
||||
|
||||
SHA256::SHA256 (InputStream& input, int64 numBytesToRead)
|
||||
{
|
||||
SHA256Processor processor;
|
||||
processor.processStream (input, numBytesToRead, result);
|
||||
}
|
||||
|
||||
SHA256::SHA256 (const File& file)
|
||||
{
|
||||
FileInputStream fin (file);
|
||||
|
||||
if (fin.getStatus().wasOk())
|
||||
{
|
||||
SHA256Processor processor;
|
||||
processor.processStream (fin, -1, result);
|
||||
}
|
||||
else
|
||||
{
|
||||
zerostruct (result);
|
||||
}
|
||||
}
|
||||
|
||||
SHA256::SHA256 (CharPointer_UTF8 utf8) noexcept
|
||||
{
|
||||
jassert (utf8.getAddress() != nullptr);
|
||||
process (utf8.getAddress(), utf8.sizeInBytes() - 1);
|
||||
}
|
||||
|
||||
void SHA256::process (const void* data, size_t numBytes)
|
||||
{
|
||||
MemoryInputStream m (data, numBytes, false);
|
||||
SHA256Processor processor;
|
||||
processor.processStream (m, -1, result);
|
||||
}
|
||||
|
||||
MemoryBlock SHA256::getRawData() const
|
||||
{
|
||||
return MemoryBlock (result, sizeof (result));
|
||||
}
|
||||
|
||||
String SHA256::toHexString() const
|
||||
{
|
||||
return String::toHexString (result, sizeof (result), 0);
|
||||
}
|
||||
|
||||
bool SHA256::operator== (const SHA256& other) const noexcept { return memcmp (result, other.result, sizeof (result)) == 0; }
|
||||
bool SHA256::operator!= (const SHA256& other) const noexcept { return ! operator== (other); }
|
||||
|
||||
|
||||
//==============================================================================
|
||||
#if JUCE_UNIT_TESTS
|
||||
|
||||
class SHA256Tests : public UnitTest
|
||||
{
|
||||
public:
|
||||
SHA256Tests()
|
||||
: UnitTest ("SHA-256", UnitTestCategories::cryptography)
|
||||
{}
|
||||
|
||||
void test (const char* input, const char* expected)
|
||||
{
|
||||
{
|
||||
SHA256 hash (input, strlen (input));
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
CharPointer_UTF8 utf8 (input);
|
||||
SHA256 hash (utf8);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
|
||||
{
|
||||
MemoryInputStream m (input, strlen (input), false);
|
||||
SHA256 hash (m);
|
||||
expectEquals (hash.toHexString(), String (expected));
|
||||
}
|
||||
}
|
||||
|
||||
void runTest() override
|
||||
{
|
||||
beginTest ("SHA256");
|
||||
|
||||
test ("", "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
|
||||
test ("The quick brown fox jumps over the lazy dog", "d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592");
|
||||
test ("The quick brown fox jumps over the lazy dog.", "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c");
|
||||
}
|
||||
};
|
||||
|
||||
static SHA256Tests sha256UnitTests;
|
||||
|
||||
#endif
|
||||
|
||||
} // namespace juce
|
||||
|
||||
@ -1,108 +1,108 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
SHA-256 secure hash generator.
|
||||
|
||||
Create one of these objects from a block of source data or a stream, and it
|
||||
calculates the SHA-256 hash of that data.
|
||||
|
||||
You can retrieve the hash as a raw 32-byte block, or as a 64-digit hex string.
|
||||
@see MD5
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API SHA256
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an empty SHA256 object.
|
||||
The default constructor just creates a hash filled with zeros. (This is not
|
||||
equal to the hash of an empty block of data).
|
||||
*/
|
||||
SHA256();
|
||||
|
||||
/** Destructor. */
|
||||
~SHA256();
|
||||
|
||||
/** Creates a copy of another SHA256. */
|
||||
SHA256 (const SHA256&);
|
||||
|
||||
/** Copies another SHA256. */
|
||||
SHA256& operator= (const SHA256&);
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a hash from a block of raw data. */
|
||||
explicit SHA256 (const MemoryBlock& data);
|
||||
|
||||
/** Creates a hash from a block of raw data. */
|
||||
SHA256 (const void* data, size_t numBytes);
|
||||
|
||||
/** Creates a hash from the contents of a stream.
|
||||
|
||||
This will read from the stream until the stream is exhausted, or until
|
||||
maxBytesToRead bytes have been read. If maxBytesToRead is negative, the entire
|
||||
stream will be read.
|
||||
*/
|
||||
SHA256 (InputStream& input, int64 maxBytesToRead = -1);
|
||||
|
||||
/** Reads a file and generates the hash of its contents.
|
||||
If the file can't be opened, the hash will be left uninitialised (i.e. full
|
||||
of zeros).
|
||||
*/
|
||||
explicit SHA256 (const File& file);
|
||||
|
||||
/** Creates a checksum from a UTF-8 buffer.
|
||||
E.g.
|
||||
@code SHA256 checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit SHA256 (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the hash as a 32-byte block of data. */
|
||||
MemoryBlock getRawData() const;
|
||||
|
||||
/** Returns the checksum as a 64-digit hex string. */
|
||||
String toHexString() const;
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const SHA256&) const noexcept;
|
||||
bool operator!= (const SHA256&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result[32] = {};
|
||||
void process (const void*, size_t);
|
||||
|
||||
JUCE_LEAK_DETECTOR (SHA256)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2022 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
|
||||
Agreement and JUCE Privacy Policy.
|
||||
|
||||
End User License Agreement: www.juce.com/juce-7-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
SHA-256 secure hash generator.
|
||||
|
||||
Create one of these objects from a block of source data or a stream, and it
|
||||
calculates the SHA-256 hash of that data.
|
||||
|
||||
You can retrieve the hash as a raw 32-byte block, or as a 64-digit hex string.
|
||||
@see MD5
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API SHA256
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an empty SHA256 object.
|
||||
The default constructor just creates a hash filled with zeros. (This is not
|
||||
equal to the hash of an empty block of data).
|
||||
*/
|
||||
SHA256();
|
||||
|
||||
/** Destructor. */
|
||||
~SHA256();
|
||||
|
||||
/** Creates a copy of another SHA256. */
|
||||
SHA256 (const SHA256&);
|
||||
|
||||
/** Copies another SHA256. */
|
||||
SHA256& operator= (const SHA256&);
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a hash from a block of raw data. */
|
||||
explicit SHA256 (const MemoryBlock& data);
|
||||
|
||||
/** Creates a hash from a block of raw data. */
|
||||
SHA256 (const void* data, size_t numBytes);
|
||||
|
||||
/** Creates a hash from the contents of a stream.
|
||||
|
||||
This will read from the stream until the stream is exhausted, or until
|
||||
maxBytesToRead bytes have been read. If maxBytesToRead is negative, the entire
|
||||
stream will be read.
|
||||
*/
|
||||
SHA256 (InputStream& input, int64 maxBytesToRead = -1);
|
||||
|
||||
/** Reads a file and generates the hash of its contents.
|
||||
If the file can't be opened, the hash will be left uninitialised (i.e. full
|
||||
of zeros).
|
||||
*/
|
||||
explicit SHA256 (const File& file);
|
||||
|
||||
/** Creates a checksum from a UTF-8 buffer.
|
||||
E.g.
|
||||
@code SHA256 checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit SHA256 (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the hash as a 32-byte block of data. */
|
||||
MemoryBlock getRawData() const;
|
||||
|
||||
/** Returns the checksum as a 64-digit hex string. */
|
||||
String toHexString() const;
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const SHA256&) const noexcept;
|
||||
bool operator!= (const SHA256&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result[32] = {};
|
||||
void process (const void*, size_t);
|
||||
|
||||
JUCE_LEAK_DETECTOR (SHA256)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,114 +1,114 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2020 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 6 End-User License
|
||||
Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).
|
||||
|
||||
End User License Agreement: www.juce.com/juce-6-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Whirlpool hash class.
|
||||
|
||||
The Whirlpool algorithm was developed by
|
||||
<a href="mailto:pbarreto@scopus.com.br">Paulo S. L. M. Barreto</a> and
|
||||
<a href="mailto:vincent.rijmen@cryptomathic.com">Vincent Rijmen</a>.
|
||||
|
||||
See
|
||||
P.S.L.M. Barreto, V. Rijmen,
|
||||
"The Whirlpool hashing function"
|
||||
NESSIE submission, 2000 (tweaked version, 2001),
|
||||
https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip
|
||||
|
||||
@see SHA256, MD5
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API Whirlpool
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an empty Whirlpool object.
|
||||
The default constructor just creates a hash filled with zeros. (This is not
|
||||
equal to the hash of an empty block of data).
|
||||
*/
|
||||
Whirlpool() noexcept;
|
||||
|
||||
/** Destructor. */
|
||||
~Whirlpool() noexcept;
|
||||
|
||||
/** Creates a copy of another Whirlpool. */
|
||||
Whirlpool (const Whirlpool& other) noexcept;
|
||||
|
||||
/** Copies another Whirlpool. */
|
||||
Whirlpool& operator= (const Whirlpool& other) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a hash from a block of raw data. */
|
||||
explicit Whirlpool (const MemoryBlock&);
|
||||
|
||||
/** Creates a hash from a block of raw data. */
|
||||
Whirlpool (const void* data, size_t numBytes);
|
||||
|
||||
/** Creates a hash from the contents of a stream.
|
||||
|
||||
This will read from the stream until the stream is exhausted, or until
|
||||
maxBytesToRead bytes have been read. If maxBytesToRead is negative, the entire
|
||||
stream will be read.
|
||||
*/
|
||||
Whirlpool (InputStream& input, int64 maxBytesToRead = -1);
|
||||
|
||||
/** Reads a file and generates the hash of its contents.
|
||||
If the file can't be opened, the hash will be left uninitialised
|
||||
(i.e. full of zeros).
|
||||
*/
|
||||
explicit Whirlpool (const File& file);
|
||||
|
||||
/** Creates a checksum from a UTF-8 buffer.
|
||||
E.g.
|
||||
@code Whirlpool checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit Whirlpool (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the hash as a 64-byte block of data. */
|
||||
MemoryBlock getRawData() const;
|
||||
|
||||
/** Returns the checksum as a 128-digit hex string. */
|
||||
String toHexString() const;
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const Whirlpool&) const noexcept;
|
||||
bool operator!= (const Whirlpool&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result [64];
|
||||
void process (const void*, size_t);
|
||||
|
||||
JUCE_LEAK_DETECTOR (Whirlpool)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2022 - Raw Material Software Limited
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
By using JUCE, you agree to the terms of both the JUCE 7 End-User License
|
||||
Agreement and JUCE Privacy Policy.
|
||||
|
||||
End User License Agreement: www.juce.com/juce-7-licence
|
||||
Privacy Policy: www.juce.com/juce-privacy-policy
|
||||
|
||||
Or: You may also use this code under the terms of the GPL v3 (see
|
||||
www.gnu.org/licenses).
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Whirlpool hash class.
|
||||
|
||||
The Whirlpool algorithm was developed by
|
||||
<a href="mailto:pbarreto@scopus.com.br">Paulo S. L. M. Barreto</a> and
|
||||
<a href="mailto:vincent.rijmen@cryptomathic.com">Vincent Rijmen</a>.
|
||||
|
||||
See
|
||||
P.S.L.M. Barreto, V. Rijmen,
|
||||
"The Whirlpool hashing function"
|
||||
NESSIE submission, 2000 (tweaked version, 2001),
|
||||
https://www.cosic.esat.kuleuven.ac.be/nessie/workshop/submissions/whirlpool.zip
|
||||
|
||||
@see SHA256, MD5
|
||||
|
||||
@tags{Cryptography}
|
||||
*/
|
||||
class JUCE_API Whirlpool
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates an empty Whirlpool object.
|
||||
The default constructor just creates a hash filled with zeros. (This is not
|
||||
equal to the hash of an empty block of data).
|
||||
*/
|
||||
Whirlpool() noexcept;
|
||||
|
||||
/** Destructor. */
|
||||
~Whirlpool() noexcept;
|
||||
|
||||
/** Creates a copy of another Whirlpool. */
|
||||
Whirlpool (const Whirlpool& other) noexcept;
|
||||
|
||||
/** Copies another Whirlpool. */
|
||||
Whirlpool& operator= (const Whirlpool& other) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Creates a hash from a block of raw data. */
|
||||
explicit Whirlpool (const MemoryBlock&);
|
||||
|
||||
/** Creates a hash from a block of raw data. */
|
||||
Whirlpool (const void* data, size_t numBytes);
|
||||
|
||||
/** Creates a hash from the contents of a stream.
|
||||
|
||||
This will read from the stream until the stream is exhausted, or until
|
||||
maxBytesToRead bytes have been read. If maxBytesToRead is negative, the entire
|
||||
stream will be read.
|
||||
*/
|
||||
Whirlpool (InputStream& input, int64 maxBytesToRead = -1);
|
||||
|
||||
/** Reads a file and generates the hash of its contents.
|
||||
If the file can't be opened, the hash will be left uninitialised
|
||||
(i.e. full of zeros).
|
||||
*/
|
||||
explicit Whirlpool (const File& file);
|
||||
|
||||
/** Creates a checksum from a UTF-8 buffer.
|
||||
E.g.
|
||||
@code Whirlpool checksum (myString.toUTF8());
|
||||
@endcode
|
||||
*/
|
||||
explicit Whirlpool (CharPointer_UTF8 utf8Text) noexcept;
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the hash as a 64-byte block of data. */
|
||||
MemoryBlock getRawData() const;
|
||||
|
||||
/** Returns the checksum as a 128-digit hex string. */
|
||||
String toHexString() const;
|
||||
|
||||
//==============================================================================
|
||||
bool operator== (const Whirlpool&) const noexcept;
|
||||
bool operator!= (const Whirlpool&) const noexcept;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
uint8 result [64];
|
||||
void process (const void*, size_t);
|
||||
|
||||
JUCE_LEAK_DETECTOR (Whirlpool)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
|
||||
Reference in New Issue
Block a user