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>

Collaboration diagram for MD5:

[legend]

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

Detailed Description

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.

Definition at line 65 of file md5.h.

Member Typedef Documentation

◆ uint1

typedef unsigned char MD5::uint1

private

Definition at line 93 of file md5.h.

◆ uint2

typedef unsigned short int MD5::uint2

private

Definition at line 92 of file md5.h.

◆ uint4

typedef unsigned int MD5::uint4

private

Definition at line 91 of file md5.h.

Constructor & Destructor Documentation

◆ MD5() [1/5]

MD5::MD5 ( )

Definition at line 62 of file md5.cpp.

 {
   init();
 }

References init().

◆ MD5() [2/5]

MD5::MD5 ( unsigned char * string )

◆ MD5() [3/5]

MD5::MD5 ( std::istream & stream )

Definition at line 237 of file md5.cpp.

                           {
  
   init();  // must called by all constructors
   update (stream);
   finalize();
 }

References finalize(), init(), and update().

◆ MD5() [4/5]

MD5::MD5 ( FILE * file )

Definition at line 227 of file md5.cpp.

                   {
  
   init();  // must be called be all constructors
   update(file);
   finalize ();
 }

References finalize(), init(), and update().

◆ MD5() [5/5]

MD5::MD5 ( std::ifstream & stream )

Definition at line 246 of file md5.cpp.

                            {
  
   init();  // must called by all constructors
   update (stream);
   finalize();
 }

References finalize(), init(), and update().

Member Function Documentation

◆ decode()

void MD5::decode	(	uint4 *	dest,
		uint1 *	src,
		uint4	length
	)

staticprivate

Definition at line 449 of file md5.cpp.

                                                        {
  
   unsigned int i, j;
  
   for (i = 0, j = 0; j < len; i++, j += 4)
     output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
       (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
 }

Referenced by transform().

◆ encode()

void MD5::encode	(	uint1 *	dest,
		uint4 *	src,
		uint4	length
	)

staticprivate

Definition at line 432 of file md5.cpp.

                                                         {
  
   unsigned int i, j;
  
   for (i = 0, j = 0; j < len; i++, j += 4) {
     output[j]   = (uint1)  (input[i] & 0xff);
     output[j+1] = (uint1) ((input[i] >> 8) & 0xff);
     output[j+2] = (uint1) ((input[i] >> 16) & 0xff);
     output[j+3] = (uint1) ((input[i] >> 24) & 0xff);
   }
 }

Referenced by finalize().

◆ F()

unsigned int MD5::F	(	uint4	x,
		uint4	y,
		uint4	z
	)

inlinestaticprivate

Definition at line 495 of file md5.cpp.

                                                                {
   return (x & y) | (~x & z);
 }

Referenced by FF().

◆ FF()

void MD5::FF	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)

inlinestaticprivate

Definition at line 517 of file md5.cpp.

                                        {
  a += F(b, c, d) + x + ac;
  a = rotate_left (a, s) +b;
 }

References b, F(), and rotate_left().

Referenced by transform().

◆ finalize()

void MD5::finalize ( )

Definition at line 188 of file md5.cpp.

                    {
  
   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;
  
 }

References buffer, count, digest, encode(), finalized, memset(), state, and update().

Referenced by MD5().

◆ G()

unsigned int MD5::G	(	uint4	x,
		uint4	y,
		uint4	z
	)

inlinestaticprivate

Definition at line 499 of file md5.cpp.

                                                                {
   return (x & z) | (y & ~z);
 }

Referenced by GG().

◆ GG()

void MD5::GG	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)

inlinestaticprivate

Definition at line 523 of file md5.cpp.

                                       {
  a += G(b, c, d) + x + ac;
  a = rotate_left (a, s) +b;
 }

References b, G(), and rotate_left().

Referenced by transform().

◆ H()

unsigned int MD5::H	(	uint4	x,
		uint4	y,
		uint4	z
	)

inlinestaticprivate

Definition at line 503 of file md5.cpp.

                                                                {
   return x ^ y ^ z;
 }

Referenced by HH().

◆ hex_digest()

QString MD5::hex_digest ( )

Definition at line 271 of file md5.cpp.

                        {
  
   int i;
   char *s= new char[33];
  
   if (!finalized){
     std::cerr << "MD5::hex_digest:  Can't get digest if you haven't "<<
       "finalized the digest!" << std::endl;
     return "";
   }
  
   for (i=0; i<16; i++)
     sprintf(s+i*2, "%02x", digest[i]);
  
   s[32]='\0';
  
   QString result(s);
   delete s;
   return result;
 }

References digest, and finalized.

Referenced by filesMatch(), and getMD5().

◆ HH()

void MD5::HH	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)

inlinestaticprivate

Definition at line 529 of file md5.cpp.

                                       {
  a += H(b, c, d) + x + ac;
  a = rotate_left (a, s) +b;
 }

References b, H(), and rotate_left().

Referenced by transform().

◆ I()

unsigned int MD5::I	(	uint4	x,
		uint4	y,
		uint4	z
	)

inlinestaticprivate

Definition at line 507 of file md5.cpp.

                                                                {
   return y ^ (x | ~z);
 }

Referenced by II().

◆ II()

void MD5::II	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)

inlinestaticprivate

Definition at line 535 of file md5.cpp.

                                                {
  a += I(b, c, d) + x + ac;
  a = rotate_left (a, s) +b;
 }

References b, I(), and rotate_left().

Referenced by transform().

◆ init()

void MD5::init ( )

private

Definition at line 297 of file md5.cpp.

               {
   finalized=0;  // we just started!
  
   // Nothing counted, so count=0
   count[0] = 0;
   count[1] = 0;
  
   // Load magic initialization constants.
   state[0] = 0x67452301;
   state[1] = 0xefcdab89;
   state[2] = 0x98badcfe;
   state[3] = 0x10325476;
 }

References count, finalized, and state.

Referenced by MD5().

◆ memcpy()

void MD5::memcpy	(	uint1 *	dest,
		uint1 *	src,
		uint4	length
	)

staticprivate

Definition at line 463 of file md5.cpp.

                                                        {
  
   unsigned int i;
  
   for (i = 0; i < len; i++)
     output[i] = input[i];
 }

Referenced by raw_digest(), and update().

◆ memset()

void MD5::memset	(	uint1 *	start,
		uint1	val,
		uint4	length
	)

staticprivate

Definition at line 474 of file md5.cpp.

                                                       {
  
   unsigned int i;
  
   for (i = 0; i < len; i++)
     output[i] = value;
 }

Referenced by finalize(), and transform().

◆ raw_digest()

unsigned char * MD5::raw_digest ( )

Definition at line 255 of file md5.cpp.

                               {
  
   uint1 *s = new uint1[16];
  
   if (!finalized){
     std::cerr << "MD5::raw_digest:  Can't get digest if you haven't "<<
       "finalized the digest!" << std::endl;
     return ( (unsigned char*) "");
   }
  
   memcpy(s, digest, 16);
   return s;
 }

References digest, finalized, and memcpy().

◆ rotate_left()

unsigned int MD5::rotate_left	(	uint4	x,
		uint4	n
	)

inlinestaticprivate

Definition at line 486 of file md5.cpp.

                                                       {
   return (x << n) | (x >> (32-n))  ;
 }

Referenced by FF(), GG(), HH(), and II().

◆ transform()

void MD5::transform ( uint1 * buffer )

private

Definition at line 338 of file md5.cpp.

                                    {
  
   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));
  
 }

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().

◆ update() [1/4]

void MD5::update ( FILE * file )

Definition at line 119 of file md5.cpp.

                           {
  
   unsigned char buffer[1024];
   int len;
  
   while (true)
   {
     len=fread(buffer, 1, 1024, file);
     if(!len)
     {  break; }
       
     update(buffer, len);
    }
  
   fclose (file);
  
 }

References buffer, and update().

◆ update() [2/4]

void MD5::update ( std::ifstream & stream )

Definition at line 166 of file md5.cpp.

                                    {
  
   unsigned char buffer[1024];
   int len;
  
   while (stream.good()){
     stream.read((char*)buffer, 1024); // note that return value of read is unusable.
     len=stream.gcount();
     update(buffer, len);
   }
  
 }

References buffer, and update().

◆ update() [3/4]

void MD5::update ( std::istream & stream )

Definition at line 145 of file md5.cpp.

                                   {
  
   unsigned char buffer[1024];
   int len;
  
   while (stream.good()){
     stream.read((char*)buffer, 1024); // note that return value of read is unusable.
     len=stream.gcount();
     update(buffer, len);
   }
  
 }

References buffer, and update().

◆ update() [4/4]

void MD5::update	(	unsigned char *	input,
		unsigned int	input_length
	)

Definition at line 71 of file md5.cpp.

                                                   {
  
   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);
 }

References buffer, count, finalized, memcpy(), and transform().

Referenced by finalize(), MD5(), and update().

Member Data Documentation

◆ buffer

uint1 MD5::buffer[64]

private

Definition at line 98 of file md5.h.

Referenced by finalize(), and update().

◆ count

uint4 MD5::count[2]

private

Definition at line 97 of file md5.h.

Referenced by finalize(), init(), and update().

◆ digest

uint1 MD5::digest[16]

private

Definition at line 99 of file md5.h.

Referenced by finalize(), hex_digest(), and raw_digest().

◆ finalized

uint1 MD5::finalized

private

Definition at line 100 of file md5.h.

Referenced by finalize(), hex_digest(), init(), raw_digest(), transform(), and update().

◆ state

uint4 MD5::state[4]

private

Definition at line 96 of file md5.h.

Referenced by finalize(), init(), and transform().

The documentation for this class was generated from the following files:

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ uint1

◆ uint2

◆ uint4

Constructor & Destructor Documentation

◆ MD5() [1/5]

◆ MD5() [2/5]

◆ MD5() [3/5]

◆ MD5() [4/5]

◆ MD5() [5/5]

Member Function Documentation

◆ decode()

◆ encode()

◆ F()

◆ FF()

◆ finalize()

◆ G()

◆ GG()

◆ H()

◆ hex_digest()

◆ HH()

◆ I()

◆ II()

◆ init()

◆ memcpy()

◆ memset()

◆ raw_digest()

◆ rotate_left()

◆ transform()

◆ update() [1/4]

◆ update() [2/4]

◆ update() [3/4]

◆ update() [4/4]

Member Data Documentation

◆ buffer

◆ count

◆ digest

◆ finalized

◆ state