#include <md5.h>

Public Member Functions
	TMd5 ()
	TMd5 (const PSIn &SIn)
	TMd5 (TSIn &)
void	Save (TSOut &)
void	Add (uchar *InBf, const int &InBfL)
void	Add (const PSIn &SIn)
void	Def ()
void	GetSigMem (TMem &Mem) const
TStr	GetSigStr () const
Static Public Member Functions
static PMd5	New ()
static PMd5	New (const PSIn &SIn)
static PMd5	Load (TSIn &SIn)
static TStr	GetMd5SigStr (const PSIn &SIn)
static TStr	GetMd5SigStr (const TStr &Str)
static TStr	GetMd5SigStr (const TMem &Mem)
static bool	Check ()
Private Types
typedef TB4Def::TB4	uint4
typedef TB2Def::TB2	uint2
typedef TB1Def::TB1	uint1
Private Member Functions
void	Init ()
void	Transform (uint1 *buffer)
	UndefCopyAssign (TMd5)
Static Private Member Functions
static void	Encode (uint1 Dst, uint4 Src, uint4 Len)
static void	Decode (uint4 Dst, uint1 Src, uint4 Len)
static void	MemCpy (uint1 Dst, uint1 Src, uint4 Len)
static void	MemSet (uint1 *Start, uint1 Val, uint4 Len)
static uint4	RotateLeft (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
TCRef	CRef
uint4	state [4]
uint4	count [2]
uint1	buffer [64]
uint1	Sig [16]
bool	DefP
Friends
class	TPt< TMd5 >
class	TMd5Sig

Detailed Description

Definition at line 5 of file md5.h.

Member Typedef Documentation

typedef TB1Def::TB1 TMd5::uint1 [private]

Definition at line 10 of file md5.h.

typedef TB2Def::TB2 TMd5::uint2 [private]

Definition at line 9 of file md5.h.

typedef TB4Def::TB4 TMd5::uint4 [private]

Definition at line 8 of file md5.h.

Constructor & Destructor Documentation

TMd5::TMd5 ( ) [inline]

Definition at line 48 of file md5.h.

{Init();}

TMd5::TMd5 ( const PSIn & SIn ) [inline]

Definition at line 50 of file md5.h.

{Init(); Add(SIn); Def();}

TMd5::TMd5 ( TSIn & ) [inline]

Definition at line 52 of file md5.h.

{Fail;}

Member Function Documentation

void TMd5::Add	(	uchar *	InBf,
		const int &	InBfL
	)

Definition at line 148 of file md5.cpp.

                                           {
  IAssert(!DefP);
  // compute number of bytes mod 64
  uint4 BfX=uint((count[0]>>3) & 0x3F);

  // update number of bits
  if ((count[0]+=((uint4)InBfL<<3))<((uint4)InBfL<<3)){
    count[1]++;}
  count[1]+=((uint4)InBfL>>29);

  uint4 BfSpace=64-BfX; // how much space is left in buffer

  // transform as many times as possible.
  uint4 InX;
  if (uint(InBfL)>=BfSpace) { // ie. we have enough to fill the buffer
    // fill the rest of the buffer and transform
    MemCpy(buffer+BfX, InBf, BfSpace);
    Transform(buffer);
    // now, transform each 64-byte piece of the InBf, bypassing the buffer
    for (InX=BfSpace; InX+63<uint(InBfL); InX+=64){Transform(InBf+InX);}
    BfX=0; // so we can buffer remaining
  } else {
    InX=0; // so we can buffer the whole InBf
  }

  // and here we do the buffering:
  MemCpy(buffer+BfX, InBf+InX, InBfL-InX);
}

void TMd5::Add ( const PSIn & SIn )

Definition at line 177 of file md5.cpp.

                             {
  uchar Bf[1024];
  while (SIn->Len()>0){
    int BfL=1024;
    if (SIn->Len()<BfL){BfL=SIn->Len();}
    SIn->GetBf(Bf, BfL);
    Add(Bf, BfL);
  }
}

bool TMd5::Check ( ) [static]

Definition at line 224 of file md5.cpp.

                {
  return
   (TMd5::GetMd5SigStr("")=="D41D8CD98F00B204E9800998ECF8427E")&&
   (TMd5::GetMd5SigStr("a")=="0CC175B9C0F1B6A831C399E269772661")&&
   (TMd5::GetMd5SigStr("abc")=="900150983CD24FB0D6963F7D28E17F72")&&
   (TMd5::GetMd5SigStr("message digest")=="F96B697D7CB7938D525A2F31AAF161D0")&&
   (TMd5::GetMd5SigStr("abcdefghijklmnopqrstuvwxyz")=="C3FCD3D76192E4007DFB496CCA67E13B")&&
   (TMd5::GetMd5SigStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")==
    "D174AB98D277D9F5A5611C2C9F419D9F")&&
   (TMd5::GetMd5SigStr("12345678901234567890123456789012345678901234567890123456789012345678901234567890")==
    "57EDF4A22BE3C955AC49DA2E2107B67A");
}

void TMd5::Decode	(	uint4 *	Dst,
		uint1 *	Src,
		uint4	Len
	)		`[static, private]`

Definition at line 140 of file md5.cpp.

                                                       {
  for (uint4 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 TMd5::Def ( )

Definition at line 187 of file md5.cpp.

              {
  unsigned char bits[8];
  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};

  IAssert(!DefP);
  Encode(bits, count, 8); // save number of bits

  // Pad out to 56 mod 64.
  uint index=uint4((count[0] >> 3) & 0x3f);
  uint padLen=(index<56) ? (56-index) : (120-index);
  Add(PADDING, padLen);

  Add(bits, 8); // append length (before padding)
  Encode(Sig, state, 16); // store state in digest
  MemSet(buffer, 0, sizeof(*buffer)); // zeroize sensitive information
  DefP=true;
}

void TMd5::Encode	(	uint1 *	Dst,
		uint4 *	Src,
		uint4	Len
	)		`[static, private]`

Definition at line 129 of file md5.cpp.

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

static uint4 TMd5::F	(	uint4	x,
		uint4	y,
		uint4	z
	)		`[inline, static, private]`

Definition at line 32 of file md5.h.

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

static void TMd5::FF	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)		`[inline, static, private]`

Definition at line 38 of file md5.h.

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

static uint4 TMd5::G	(	uint4	x,
		uint4	y,
		uint4	z
	)		`[inline, static, private]`

Definition at line 33 of file md5.h.

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

static TStr TMd5::GetMd5SigStr ( const PSIn & SIn ) [inline, static]

Definition at line 66 of file md5.h.

                                           {
    PMd5 Md5=TMd5::New(SIn); return Md5->GetSigStr();}

static TStr TMd5::GetMd5SigStr ( const TStr & Str ) [inline, static]

Definition at line 68 of file md5.h.

                                           {
    return GetMd5SigStr(TStrIn::New(Str));}

static TStr TMd5::GetMd5SigStr ( const TMem & Mem ) [inline, static]

Definition at line 70 of file md5.h.

                                           {
    return GetMd5SigStr(TMemIn::New(Mem));}

void TMd5::GetSigMem ( TMem & Mem ) const

Definition at line 208 of file md5.cpp.

                                    {
  IAssert(DefP);
  Mem.Gen(16);
  for (int CdN=0; CdN<16; CdN++){Mem+=Sig[CdN];}
}

TStr TMd5::GetSigStr ( ) const

Definition at line 214 of file md5.cpp.

                           {
  IAssert(DefP);
  TChA ChA(32);
  for (int CdN=0; CdN<16; CdN++){
    ChA+=TCh::GetHexCh(Sig[CdN]/16);
    ChA+=TCh::GetHexCh(Sig[CdN]%16);
  }
  return ChA;
}

static void TMd5::GG	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)		`[inline, static, private]`

Definition at line 40 of file md5.h.

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

static uint4 TMd5::H	(	uint4	x,
		uint4	y,
		uint4	z
	)		`[inline, static, private]`

Definition at line 34 of file md5.h.

{return x^y^z;}

static void TMd5::HH	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)		`[inline, static, private]`

Definition at line 42 of file md5.h.

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

static uint4 TMd5::I	(	uint4	x,
		uint4	y,
		uint4	z
	)		`[inline, static, private]`

Definition at line 35 of file md5.h.

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

static void TMd5::II	(	uint4 &	a,
		uint4	b,
		uint4	c,
		uint4	d,
		uint4	x,
		uint4	s,
		uint4	ac
	)		`[inline, static, private]`

Definition at line 44 of file md5.h.

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

void TMd5::Init ( ) [private]

Definition at line 3 of file md5.cpp.

               {
  DefP=false; // 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;
}

static PMd5 TMd5::Load ( TSIn & SIn ) [inline, static]

Definition at line 53 of file md5.h.

{return new TMd5(SIn);}

static void TMd5::MemCpy	(	uint1 *	Dst,
		uint1 *	Src,
		uint4	Len
	)		`[inline, static, private]`

Definition at line 24 of file md5.h.

                                                       {
    for (uint4 ChN=0; ChN<Len; ChN++){Dst[ChN]=Src[ChN];}}

static void TMd5::MemSet	(	uint1 *	Start,
		uint1	Val,
		uint4	Len
	)		`[inline, static, private]`

Definition at line 26 of file md5.h.

                                                        {
    for (uint4 ChN=0; ChN<Len; ChN++){Start[ChN]=Val;}}

static PMd5 TMd5::New ( ) [inline, static]

Definition at line 49 of file md5.h.

{return PMd5(new TMd5());}

static PMd5 TMd5::New ( const PSIn & SIn ) [inline, static]

Definition at line 51 of file md5.h.

{return PMd5(new TMd5(SIn));}

static uint4 TMd5::RotateLeft	(	uint4	x,
		uint4	n
	)		`[inline, static, private]`

Definition at line 30 of file md5.h.

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

void TMd5::Save ( TSOut & ) [inline]

Definition at line 54 of file md5.h.

{Fail;}

void TMd5::Transform ( uint1 * buffer ) [private]

Definition at line 18 of file md5.cpp.

                                   {
  static const int S11=7;
  static const int S12=12;
  static const int S13=17;
  static const int S14=22;
  static const int S21=5;
  static const int S22=9;
  static const int S23=14;
  static const int S24=20;
  static const int S31=4;
  static const int S32=11;
  static const int S33=16;
  static const int S34=23;
  static const int S41=6;
  static const int S42=10;
  static const int S43=15;
  static const int S44=21;

  uint4 a=state[0];
  uint4 b=state[1];
  uint4 c=state[2];
  uint4 d=state[3];
  uint4 x[16];

  Decode(x, block, 64);

  IAssert(!DefP);  // 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));
}

TMd5::UndefCopyAssign ( TMd5 ) [private]

Friends And Related Function Documentation

friend class TMd5Sig [friend]

Definition at line 76 of file md5.h.

friend class TPt< TMd5 > [friend]

Definition at line 5 of file md5.h.

Member Data Documentation

uint1 TMd5::buffer[64] [private]

Definition at line 15 of file md5.h.

uint4 TMd5::count[2] [private]

Definition at line 14 of file md5.h.

TCRef TMd5::CRef [private]

Definition at line 5 of file md5.h.

bool TMd5::DefP [private]

Definition at line 17 of file md5.h.

uint1 TMd5::Sig[16] [private]

Definition at line 16 of file md5.h.

uint4 TMd5::state[4] [private]

Definition at line 13 of file md5.h.

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

glib-core/md5.h
glib-core/md5.cpp

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation