SNAP Library 2.0, Developer Reference  2013-05-13 16:33:57
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes | Friends
TMd5 Class Reference

#include <md5.h>

Collaboration diagram for TMd5:
Collaboration graph
[legend]

List of all members.

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.

References Fail.

{Fail;}

Member Function Documentation

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

Definition at line 148 of file md5.cpp.

References buffer, count, DefP, IAssert, MemCpy(), and Transform().

Referenced by Add(), Def(), and TMd5Sig::TMd5Sig().

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

Here is the call graph for this function:

Here is the caller graph for this function:

void TMd5::Add ( const PSIn &  SIn)

Definition at line 177 of file md5.cpp.

References Add(), TSIn::GetBf(), and TSIn::Len().

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

Here is the call graph for this function:

bool TMd5::Check ( ) [static]

Definition at line 224 of file md5.cpp.

References GetMd5SigStr().

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

Here is the call graph for this function:

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

Definition at line 140 of file md5.cpp.

Referenced by Transform().

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

Here is the caller graph for this function:

void TMd5::Def ( )

Definition at line 187 of file md5.cpp.

References Add(), buffer, count, DefP, Encode(), IAssert, MemSet(), Sig, and state.

Referenced by TMd5Sig::TMd5Sig().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 129 of file md5.cpp.

Referenced by Def().

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

Here is the caller graph for this function:

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.

Referenced by Transform().

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

Here is the caller graph for this function:

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.

References New().

Referenced by Check().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 68 of file md5.h.

References TStrIn::New().

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

Here is the call graph for this function:

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

Definition at line 70 of file md5.h.

References TMemIn::New().

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

Here is the call graph for this function:

void TMd5::GetSigMem ( TMem &  Mem) const

Definition at line 208 of file md5.cpp.

References DefP, TMem::Gen(), IAssert, and Sig.

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

Here is the call graph for this function:

TStr TMd5::GetSigStr ( ) const

Definition at line 214 of file md5.cpp.

References DefP, TCh::GetHexCh(), IAssert, and Sig.

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

Here is the call graph for this function:

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.

Referenced by Transform().

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

Here is the caller graph for this function:

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.

Referenced by Transform().

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

Here is the caller graph for this function:

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.

Referenced by Transform().

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

Here is the caller graph for this function:

void TMd5::Init ( ) [private]

Definition at line 3 of file md5.cpp.

References count, DefP, and state.

               {
  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.

Referenced by Add().

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

Here is the caller graph for this function:

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

Definition at line 26 of file md5.h.

Referenced by Def(), and Transform().

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

Here is the caller graph for this function:

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

Definition at line 49 of file md5.h.

Referenced by GetMd5SigStr(), and TMd5Sig::TMd5Sig().

{return PMd5(new TMd5());}

Here is the caller graph for this function:

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.

References Fail.

{Fail;}
void TMd5::Transform ( uint1 *  buffer) [private]

Definition at line 18 of file md5.cpp.

References Decode(), DefP, FF(), GG(), HH(), IAssert, II(), MemSet(), and state.

Referenced by Add().

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

Here is the call graph for this function:

Here is the caller graph for this function:

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.

Referenced by Add(), and Def().

uint4 TMd5::count[2] [private]

Definition at line 14 of file md5.h.

Referenced by Add(), Def(), and Init().

TCRef TMd5::CRef [private]

Definition at line 5 of file md5.h.

bool TMd5::DefP [private]

Definition at line 17 of file md5.h.

Referenced by Add(), Def(), GetSigMem(), GetSigStr(), Init(), and Transform().

uint1 TMd5::Sig[16] [private]

Definition at line 16 of file md5.h.

Referenced by Def(), GetSigMem(), GetSigStr(), and TMd5Sig::TMd5Sig().

uint4 TMd5::state[4] [private]

Definition at line 13 of file md5.h.

Referenced by Def(), Init(), and Transform().

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