AlbumShaper  1.0a3
Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes
MD5 Class Reference

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:
Collaboration graph
[legend]

List of all members.

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

typedef unsigned char MD5::uint1 [private]

Definition at line 93 of file md5.h.

typedef unsigned short int MD5::uint2 [private]

Definition at line 92 of file md5.h.

typedef unsigned int MD5::uint4 [private]

Definition at line 91 of file md5.h.


Constructor & Destructor Documentation

MD5::MD5 ( )

Definition at line 62 of file md5.cpp.

References init().

{
  init();
}
MD5::MD5 ( unsigned char *  string)
MD5::MD5 ( std::istream &  stream)

Definition at line 237 of file md5.cpp.

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

                          {

  init();  // must called by all constructors
  update (stream);
  finalize();
}
MD5::MD5 ( FILE *  file)

Definition at line 227 of file md5.cpp.

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

                  {

  init();  // must be called be all constructors
  update(file);
  finalize ();
}
MD5::MD5 ( std::ifstream &  stream)

Definition at line 246 of file md5.cpp.

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

                           {

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

Member Function Documentation

void MD5::decode ( uint4 dest,
uint1 src,
uint4  length 
) [static, private]

Definition at line 449 of file md5.cpp.

Referenced by transform().

                                                       {

  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);
}
void MD5::encode ( uint1 dest,
uint4 src,
uint4  length 
) [static, private]

Definition at line 432 of file md5.cpp.

Referenced by finalize().

                                                        {

  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);
  }
}
unsigned int MD5::F ( uint4  x,
uint4  y,
uint4  z 
) [inline, static, private]

Definition at line 495 of file md5.cpp.

Referenced by FF().

                                                               {
  return (x & y) | (~x & z);
}
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;

}
unsigned int MD5::G ( uint4  x,
uint4  y,
uint4  z 
) [inline, static, private]

Definition at line 499 of file md5.cpp.

Referenced by GG().

                                                               {
  return (x & z) | (y & ~z);
}
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;
}
unsigned int MD5::H ( uint4  x,
uint4  y,
uint4  z 
) [inline, static, private]

Definition at line 503 of file md5.cpp.

Referenced by HH().

                                                               {
  return x ^ y ^ z;
}
QString MD5::hex_digest ( )

Definition at line 271 of file md5.cpp.

References digest, and finalized.

Referenced by filesMatch(), and getMD5().

                       {

  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;
}
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;
}
unsigned int MD5::I ( uint4  x,
uint4  y,
uint4  z 
) [inline, static, private]

Definition at line 507 of file md5.cpp.

Referenced by II().

                                                               {
  return y ^ (x | ~z);
}
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 297 of file md5.cpp.

References count, finalized, and state.

Referenced by MD5().

              {
  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;
}
void MD5::memcpy ( uint1 dest,
uint1 src,
uint4  length 
) [static, 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];
}
void MD5::memset ( uint1 start,
uint1  val,
uint4  length 
) [static, private]

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;
}
unsigned char * MD5::raw_digest ( )

Definition at line 255 of file md5.cpp.

References digest, finalized, and memcpy().

                              {

  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;
}
unsigned int MD5::rotate_left ( uint4  x,
uint4  n 
) [inline, static, private]

Definition at line 486 of file md5.cpp.

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

                                                      {
  return (x << n) | (x >> (32-n))  ;
}
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)

Definition at line 145 of file md5.cpp.

References buffer, and update().

                                  {

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

}
void MD5::update ( FILE *  file)

Definition at line 119 of file md5.cpp.

References buffer, and update().

                          {

  unsigned char buffer[1024];
  int len;

  while (true)
  {
    len=fread(buffer, 1, 1024, file);
    if(!len)
    {  break; }
      
    update(buffer, len);
   }

  fclose (file);

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

Definition at line 166 of file md5.cpp.

References buffer, and update().

                                   {

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

}

Member Data Documentation

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


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