AlbumShaper
1.0a3
|
MD5 Support allows checksums to be computed for images, determing if they have changed since the album was saved out, and if so need to be loaded and rescaled. More...
#include <md5.h>
Public Member Functions | |
MD5 () | |
void | update (unsigned char *input, unsigned int input_length) |
void | update (std::istream &stream) |
void | update (FILE *file) |
void | update (std::ifstream &stream) |
void | finalize () |
MD5 (unsigned char *string) | |
MD5 (std::istream &stream) | |
MD5 (FILE *file) | |
MD5 (std::ifstream &stream) | |
unsigned char * | raw_digest () |
QString | hex_digest () |
Private Types | |
typedef unsigned int | uint4 |
typedef unsigned short int | uint2 |
typedef unsigned char | uint1 |
Private Member Functions | |
void | init () |
void | transform (uint1 *buffer) |
Static Private Member Functions | |
static void | encode (uint1 *dest, uint4 *src, uint4 length) |
static void | decode (uint4 *dest, uint1 *src, uint4 length) |
static void | memcpy (uint1 *dest, uint1 *src, uint4 length) |
static void | memset (uint1 *start, uint1 val, uint4 length) |
static uint4 | rotate_left (uint4 x, uint4 n) |
static uint4 | F (uint4 x, uint4 y, uint4 z) |
static uint4 | G (uint4 x, uint4 y, uint4 z) |
static uint4 | H (uint4 x, uint4 y, uint4 z) |
static uint4 | I (uint4 x, uint4 y, uint4 z) |
static void | FF (uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) |
static void | GG (uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) |
static void | HH (uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) |
static void | II (uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) |
Private Attributes | |
uint4 | state [4] |
uint4 | count [2] |
uint1 | buffer [64] |
uint1 | digest [16] |
uint1 | finalized |
MD5 Support allows checksums to be computed for images, determing if they have changed since the album was saved out, and if so need to be loaded and rescaled.
typedef unsigned char MD5::uint1 [private] |
typedef unsigned short int MD5::uint2 [private] |
typedef unsigned int MD5::uint4 [private] |
MD5::MD5 | ( | unsigned char * | string | ) |
MD5::MD5 | ( | std::istream & | stream | ) |
MD5::MD5 | ( | FILE * | file | ) |
MD5::MD5 | ( | std::ifstream & | stream | ) |
Definition at line 432 of file md5.cpp.
Referenced by finalize().
void MD5::FF | ( | uint4 & | a, |
uint4 | b, | ||
uint4 | c, | ||
uint4 | d, | ||
uint4 | x, | ||
uint4 | s, | ||
uint4 | ac | ||
) | [inline, static, private] |
Definition at line 517 of file md5.cpp.
References b, F(), and rotate_left().
Referenced by transform().
{ a += F(b, c, d) + x + ac; a = rotate_left (a, s) +b; }
void MD5::finalize | ( | ) |
Definition at line 188 of file md5.cpp.
References buffer, count, digest, encode(), finalized, memset(), state, and update().
Referenced by MD5().
{ unsigned char bits[8]; unsigned int index, padLen; static uint1 PADDING[64]={ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; if (finalized){ std::cerr << "MD5::finalize: Already finalized this digest!" << std::endl; return; } // Save number of bits encode (bits, count, 8); // Pad out to 56 mod 64. index = (uint4) ((count[0] >> 3) & 0x3f); padLen = (index < 56) ? (56 - index) : (120 - index); update (PADDING, padLen); // Append length (before padding) update (bits, 8); // Store state in digest encode (digest, state, 16); // Zeroize sensitive information memset (buffer, 0, sizeof(*buffer)); finalized=1; }
void MD5::GG | ( | uint4 & | a, |
uint4 | b, | ||
uint4 | c, | ||
uint4 | d, | ||
uint4 | x, | ||
uint4 | s, | ||
uint4 | ac | ||
) | [inline, static, private] |
Definition at line 523 of file md5.cpp.
References b, G(), and rotate_left().
Referenced by transform().
{ a += G(b, c, d) + x + ac; a = rotate_left (a, s) +b; }
QString MD5::hex_digest | ( | ) |
void MD5::HH | ( | uint4 & | a, |
uint4 | b, | ||
uint4 | c, | ||
uint4 | d, | ||
uint4 | x, | ||
uint4 | s, | ||
uint4 | ac | ||
) | [inline, static, private] |
Definition at line 529 of file md5.cpp.
References b, H(), and rotate_left().
Referenced by transform().
{ a += H(b, c, d) + x + ac; a = rotate_left (a, s) +b; }
void MD5::II | ( | uint4 & | a, |
uint4 | b, | ||
uint4 | c, | ||
uint4 | d, | ||
uint4 | x, | ||
uint4 | s, | ||
uint4 | ac | ||
) | [inline, static, private] |
Definition at line 535 of file md5.cpp.
References b, I(), and rotate_left().
Referenced by transform().
{ a += I(b, c, d) + x + ac; a = rotate_left (a, s) +b; }
void MD5::init | ( | ) | [private] |
Definition at line 463 of file md5.cpp.
Referenced by raw_digest(), and update().
{ unsigned int i; for (i = 0; i < len; i++) output[i] = input[i]; }
Definition at line 474 of file md5.cpp.
Referenced by finalize(), and transform().
{ unsigned int i; for (i = 0; i < len; i++) output[i] = value; }
void MD5::transform | ( | uint1 * | buffer | ) | [private] |
Definition at line 338 of file md5.cpp.
References b, decode(), FF(), finalized, GG(), HH(), II(), memset(), S11, S12, S13, S14, S21, S22, S23, S24, S31, S32, S33, S34, S41, S42, S43, S44, and state.
Referenced by update().
{ uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; decode (x, block, 64); assert(!finalized); // not just a user error, since the method is private /* Round 1 */ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ /* Round 2 */ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ /* Round 3 */ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ /* Round 4 */ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ state[0] += a; state[1] += b; state[2] += c; state[3] += d; // Zeroize sensitive information. memset ( (uint1 *) x, 0, sizeof(x)); }
void MD5::update | ( | unsigned char * | input, |
unsigned int | input_length | ||
) |
Definition at line 71 of file md5.cpp.
References buffer, count, finalized, memcpy(), and transform().
Referenced by finalize(), MD5(), and update().
{ uint4 input_index, buffer_index; uint4 buffer_space; // how much space is left in buffer if (finalized){ // so we can't update! std::cerr << "MD5::update: Can't update a finalized digest!" << std::endl; return; } // Compute number of bytes mod 64 buffer_index = (unsigned int)((count[0] >> 3) & 0x3F); // Update number of bits if ( (count[0] += ((uint4) input_length << 3))<((uint4) input_length << 3) ) count[1]++; count[1] += ((uint4)input_length >> 29); buffer_space = 64 - buffer_index; // how much space is left in buffer // Transform as many times as possible. if (input_length >= buffer_space) { // ie. we have enough to fill the buffer // fill the rest of the buffer and transform memcpy (buffer + buffer_index, input, buffer_space); transform (buffer); // now, transform each 64-byte piece of the input, bypassing the buffer for (input_index = buffer_space; input_index + 63 < input_length; input_index += 64) transform (input+input_index); buffer_index = 0; // so we can buffer remaining } else input_index=0; // so we can buffer the whole input // and here we do the buffering: memcpy(buffer+buffer_index, input+input_index, input_length-input_index); }
void MD5::update | ( | std::istream & | stream | ) |
void MD5::update | ( | FILE * | file | ) |
void MD5::update | ( | std::ifstream & | stream | ) |
uint1 MD5::buffer[64] [private] |
Definition at line 98 of file md5.h.
Referenced by finalize(), and update().
uint4 MD5::count[2] [private] |
Definition at line 97 of file md5.h.
Referenced by finalize(), init(), and update().
uint1 MD5::digest[16] [private] |
Definition at line 99 of file md5.h.
Referenced by finalize(), hex_digest(), and raw_digest().
uint1 MD5::finalized [private] |
Definition at line 100 of file md5.h.
Referenced by finalize(), hex_digest(), init(), raw_digest(), transform(), and update().
uint4 MD5::state[4] [private] |
Definition at line 96 of file md5.h.
Referenced by finalize(), init(), and transform().