TMd5 Class Reference

#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  )

staticprivate

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  )

staticprivate

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  )

inlinestaticprivate

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  )

inlinestaticprivate

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  )

inlinestaticprivate

Definition at line 33 of file md5.h.

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

static TStr TMd5::GetMd5SigStr ( const PSIn &  SIn )

inlinestatic

Definition at line 66 of file md5.h.

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

static TStr TMd5::GetMd5SigStr ( const TStr &  Str )

inlinestatic

Definition at line 68 of file md5.h.

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

static TStr TMd5::GetMd5SigStr ( const TMem &  Mem )

inlinestatic

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  )

inlinestaticprivate

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  )

inlinestaticprivate

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  )

inlinestaticprivate

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  )

inlinestaticprivate

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  )

inlinestaticprivate

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 )

inlinestatic

Definition at line 53 of file md5.h.

{return new TMd5(SIn);}

static void TMd5::MemCpy ( uint1 *  Dst, uint1 *  Src, uint4  Len  )

inlinestaticprivate

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  )

inlinestaticprivate

Definition at line 26 of file md5.h.

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

static PMd5 TMd5::New ( )

inlinestatic

Definition at line 49 of file md5.h.

{return PMd5(new TMd5());}

static PMd5 TMd5::New ( const PSIn &  SIn )

inlinestatic

Definition at line 51 of file md5.h.

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

static uint4 TMd5::RotateLeft ( uint4  x, uint4  n  )

inlinestaticprivate

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