SNAP Library 3.0, User Reference  2016-07-20 17:56:49
SNAP, a general purpose, high performance system for analysis and manipulation of large networks
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
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.

48 {Init();}
void Init()
Definition: md5.cpp:3
TMd5::TMd5 ( const PSIn SIn)
inline

Definition at line 50 of file md5.h.

50 {Init(); Add(SIn); Def();}
void Add(uchar *InBf, const int &InBfL)
Definition: md5.cpp:148
void Init()
Definition: md5.cpp:3
void Def()
Definition: md5.cpp:187
TMd5::TMd5 ( TSIn )
inline

Definition at line 52 of file md5.h.

52 {Fail;}
#define Fail
Definition: bd.h:238

Member Function Documentation

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

Definition at line 148 of file md5.cpp.

148  {
149  IAssert(!DefP);
150  // compute number of bytes mod 64
151  uint4 BfX=uint((count[0]>>3) & 0x3F);
152 
153  // update number of bits
154  if ((count[0]+=((uint4)InBfL<<3))<((uint4)InBfL<<3)){
155  count[1]++;}
156  count[1]+=((uint4)InBfL>>29);
157 
158  uint4 BfSpace=64-BfX; // how much space is left in buffer
159 
160  // transform as many times as possible.
161  uint4 InX;
162  if (uint(InBfL)>=BfSpace) { // ie. we have enough to fill the buffer
163  // fill the rest of the buffer and transform
164  MemCpy(buffer+BfX, InBf, BfSpace);
165  Transform(buffer);
166  // now, transform each 64-byte piece of the InBf, bypassing the buffer
167  for (InX=BfSpace; InX+63<uint(InBfL); InX+=64){Transform(InBf+InX);}
168  BfX=0; // so we can buffer remaining
169  } else {
170  InX=0; // so we can buffer the whole InBf
171  }
172 
173  // and here we do the buffering:
174  MemCpy(buffer+BfX, InBf+InX, InBfL-InX);
175 }
#define IAssert(Cond)
Definition: bd.h:262
uint4 count[2]
Definition: md5.h:14
TB4Def::TB4 uint4
Definition: md5.h:8
unsigned int uint
Definition: bd.h:11
uint1 buffer[64]
Definition: md5.h:15
void Transform(uint1 *buffer)
Definition: md5.cpp:18
static void MemCpy(uint1 *Dst, uint1 *Src, uint4 Len)
Definition: md5.h:24
bool DefP
Definition: md5.h:17
void TMd5::Add ( const PSIn SIn)

Definition at line 177 of file md5.cpp.

177  {
178  uchar Bf[1024];
179  while (SIn->Len()>0){
180  int BfL=1024;
181  if (SIn->Len()<BfL){BfL=SIn->Len();}
182  SIn->GetBf(Bf, BfL);
183  Add(Bf, BfL);
184  }
185 }
virtual int GetBf(const void *Bf, const TSize &BfL)=0
void Add(uchar *InBf, const int &InBfL)
Definition: md5.cpp:148
unsigned char uchar
Definition: bd.h:10
virtual int Len() const =0
bool TMd5::Check ( )
static

Definition at line 224 of file md5.cpp.

224  {
225  return
226  (TMd5::GetMd5SigStr("")=="D41D8CD98F00B204E9800998ECF8427E")&&
227  (TMd5::GetMd5SigStr("a")=="0CC175B9C0F1B6A831C399E269772661")&&
228  (TMd5::GetMd5SigStr("abc")=="900150983CD24FB0D6963F7D28E17F72")&&
229  (TMd5::GetMd5SigStr("message digest")=="F96B697D7CB7938D525A2F31AAF161D0")&&
230  (TMd5::GetMd5SigStr("abcdefghijklmnopqrstuvwxyz")=="C3FCD3D76192E4007DFB496CCA67E13B")&&
231  (TMd5::GetMd5SigStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")==
232  "D174AB98D277D9F5A5611C2C9F419D9F")&&
233  (TMd5::GetMd5SigStr("12345678901234567890123456789012345678901234567890123456789012345678901234567890")==
234  "57EDF4A22BE3C955AC49DA2E2107B67A");
235 }
static TStr GetMd5SigStr(const PSIn &SIn)
Definition: md5.h:66
void TMd5::Decode ( uint4 Dst,
uint1 Src,
uint4  Len 
)
staticprivate

Definition at line 140 of file md5.cpp.

140  {
141  for (uint4 i=0, j=0; j<len; i++, j+=4){
142  output[i]=
143  ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
144  (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
145  }
146 }
TB4Def::TB4 uint4
Definition: md5.h:8
void TMd5::Def ( )

Definition at line 187 of file md5.cpp.

187  {
188  unsigned char bits[8];
189  static uint1 PADDING[64]={
190  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
191  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
192  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
193 
194  IAssert(!DefP);
195  Encode(bits, count, 8); // save number of bits
196 
197  // Pad out to 56 mod 64.
198  uint index=uint4((count[0] >> 3) & 0x3f);
199  uint padLen=(index<56) ? (56-index) : (120-index);
200  Add(PADDING, padLen);
201 
202  Add(bits, 8); // append length (before padding)
203  Encode(Sig, state, 16); // store state in digest
204  MemSet(buffer, 0, sizeof(*buffer)); // zeroize sensitive information
205  DefP=true;
206 }
#define IAssert(Cond)
Definition: bd.h:262
uint4 count[2]
Definition: md5.h:14
TB4Def::TB4 uint4
Definition: md5.h:8
unsigned int uint
Definition: bd.h:11
void Add(uchar *InBf, const int &InBfL)
Definition: md5.cpp:148
uint1 buffer[64]
Definition: md5.h:15
uint4 state[4]
Definition: md5.h:13
uint1 Sig[16]
Definition: md5.h:16
TB1Def::TB1 uint1
Definition: md5.h:10
static void MemSet(uint1 *Start, uint1 Val, uint4 Len)
Definition: md5.h:26
static void Encode(uint1 *Dst, uint4 *Src, uint4 Len)
Definition: md5.cpp:129
bool DefP
Definition: md5.h:17
void TMd5::Encode ( uint1 Dst,
uint4 Src,
uint4  Len 
)
staticprivate

Definition at line 129 of file md5.cpp.

129  {
130  for (uint4 i=0, j=0; j<len; i++, j+=4){
131  output[j]=uint1(input[i] & 0xff);
132  output[j+1]=uint1((input[i]>>8) & 0xff);
133  output[j+2]=uint1((input[i]>>16) & 0xff);
134  output[j+3]=uint1((input[i]>>24) & 0xff);
135  }
136 }
TB4Def::TB4 uint4
Definition: md5.h:8
TB1Def::TB1 uint1
Definition: md5.h:10
static uint4 TMd5::F ( uint4  x,
uint4  y,
uint4  z 
)
inlinestaticprivate

Definition at line 32 of file md5.h.

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

38  {
39  a+=F(b, c, d)+x+ac; a=RotateLeft(a, s)+b;}
static uint4 F(uint4 x, uint4 y, uint4 z)
Definition: md5.h:32
static uint4 RotateLeft(uint4 x, uint4 n)
Definition: md5.h:30
static uint4 TMd5::G ( uint4  x,
uint4  y,
uint4  z 
)
inlinestaticprivate

Definition at line 33 of file md5.h.

33 {return (x&z)|(y&~z);}
static TStr TMd5::GetMd5SigStr ( const PSIn SIn)
inlinestatic

Definition at line 66 of file md5.h.

66  {
67  PMd5 Md5=TMd5::New(SIn); return Md5->GetSigStr();}
static PMd5 New()
Definition: md5.h:49
Definition: bd.h:196
static TStr TMd5::GetMd5SigStr ( const TStr Str)
inlinestatic

Definition at line 68 of file md5.h.

68  {
69  return GetMd5SigStr(TStrIn::New(Str));}
static PSIn New(const TStr &Str)
Definition: dt.h:708
static TStr GetMd5SigStr(const PSIn &SIn)
Definition: md5.h:66
static TStr TMd5::GetMd5SigStr ( const TMem Mem)
inlinestatic

Definition at line 70 of file md5.h.

70  {
71  return GetMd5SigStr(TMemIn::New(Mem));}
static PSIn New(const TMem &Mem)
Definition: dt.h:165
static TStr GetMd5SigStr(const PSIn &SIn)
Definition: md5.h:66
void TMd5::GetSigMem ( TMem Mem) const

Definition at line 208 of file md5.cpp.

208  {
209  IAssert(DefP);
210  Mem.Gen(16);
211  for (int CdN=0; CdN<16; CdN++){Mem+=Sig[CdN];}
212 }
#define IAssert(Cond)
Definition: bd.h:262
void Gen(const int &_BfL)
Definition: dt.h:123
uint1 Sig[16]
Definition: md5.h:16
bool DefP
Definition: md5.h:17
TStr TMd5::GetSigStr ( ) const

Definition at line 214 of file md5.cpp.

214  {
215  IAssert(DefP);
216  TChA ChA(32);
217  for (int CdN=0; CdN<16; CdN++){
218  ChA+=TCh::GetHexCh(Sig[CdN]/16);
219  ChA+=TCh::GetHexCh(Sig[CdN]%16);
220  }
221  return ChA;
222 }
#define IAssert(Cond)
Definition: bd.h:262
static char GetHexCh(const int &Val)
Definition: dt.h:984
uint1 Sig[16]
Definition: md5.h:16
Definition: dt.h:201
bool DefP
Definition: md5.h:17
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.

40  {
41  a+=G(b, c, d)+x+ac; a=RotateLeft(a, s)+b;}
static uint4 G(uint4 x, uint4 y, uint4 z)
Definition: md5.h:33
static uint4 RotateLeft(uint4 x, uint4 n)
Definition: md5.h:30
static uint4 TMd5::H ( uint4  x,
uint4  y,
uint4  z 
)
inlinestaticprivate

Definition at line 34 of file md5.h.

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

42  {
43  a+=H(b, c, d)+x+ac; a=RotateLeft(a, s)+b;}
static uint4 H(uint4 x, uint4 y, uint4 z)
Definition: md5.h:34
static uint4 RotateLeft(uint4 x, uint4 n)
Definition: md5.h:30
static uint4 TMd5::I ( uint4  x,
uint4  y,
uint4  z 
)
inlinestaticprivate

Definition at line 35 of file md5.h.

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

44  {
45  a+=I(b, c, d)+x+ac; a=RotateLeft(a, s)+b;}
static uint4 I(uint4 x, uint4 y, uint4 z)
Definition: md5.h:35
static uint4 RotateLeft(uint4 x, uint4 n)
Definition: md5.h:30
void TMd5::Init ( )
private

Definition at line 3 of file md5.cpp.

3  {
4  DefP=false; // we just started!
5 
6  // Nothing counted, so count=0
7  count[0]=0;
8  count[1]=0;
9 
10  // Load magic initialization constants.
11  state[0]=0x67452301;
12  state[1]=0xefcdab89;
13  state[2]=0x98badcfe;
14  state[3]=0x10325476;
15 }
uint4 count[2]
Definition: md5.h:14
uint4 state[4]
Definition: md5.h:13
bool DefP
Definition: md5.h:17
static PMd5 TMd5::Load ( TSIn SIn)
inlinestatic

Definition at line 53 of file md5.h.

53 {return new TMd5(SIn);}
TMd5()
Definition: md5.h:48
static void TMd5::MemCpy ( uint1 Dst,
uint1 Src,
uint4  Len 
)
inlinestaticprivate

Definition at line 24 of file md5.h.

24  {
25  for (uint4 ChN=0; ChN<Len; ChN++){Dst[ChN]=Src[ChN];}}
TB4Def::TB4 uint4
Definition: md5.h:8
static void TMd5::MemSet ( uint1 Start,
uint1  Val,
uint4  Len 
)
inlinestaticprivate

Definition at line 26 of file md5.h.

26  {
27  for (uint4 ChN=0; ChN<Len; ChN++){Start[ChN]=Val;}}
TB4Def::TB4 uint4
Definition: md5.h:8
static PMd5 TMd5::New ( )
inlinestatic

Definition at line 49 of file md5.h.

49 {return PMd5(new TMd5());}
TPt< TMd5 > PMd5
Definition: md5.h:5
TMd5()
Definition: md5.h:48
static PMd5 TMd5::New ( const PSIn SIn)
inlinestatic

Definition at line 51 of file md5.h.

51 {return PMd5(new TMd5(SIn));}
TPt< TMd5 > PMd5
Definition: md5.h:5
TMd5()
Definition: md5.h:48
static uint4 TMd5::RotateLeft ( uint4  x,
uint4  n 
)
inlinestaticprivate

Definition at line 30 of file md5.h.

30 {return (x<<n)|(x>>(32-n));}
void TMd5::Save ( TSOut )
inline

Definition at line 54 of file md5.h.

54 {Fail;}
#define Fail
Definition: bd.h:238
void TMd5::Transform ( uint1 buffer)
private

Definition at line 18 of file md5.cpp.

18  {
19  static const int S11=7;
20  static const int S12=12;
21  static const int S13=17;
22  static const int S14=22;
23  static const int S21=5;
24  static const int S22=9;
25  static const int S23=14;
26  static const int S24=20;
27  static const int S31=4;
28  static const int S32=11;
29  static const int S33=16;
30  static const int S34=23;
31  static const int S41=6;
32  static const int S42=10;
33  static const int S43=15;
34  static const int S44=21;
35 
36  uint4 a=state[0];
37  uint4 b=state[1];
38  uint4 c=state[2];
39  uint4 d=state[3];
40  uint4 x[16];
41 
42  Decode(x, block, 64);
43 
44  IAssert(!DefP); // not just a user error, since the method is private
45 
46  /* Round 1 */
47  FF(a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
48  FF(d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
49  FF(c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
50  FF(b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
51  FF(a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
52  FF(d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
53  FF(c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
54  FF(b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
55  FF(a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
56  FF(d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
57  FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
58  FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
59  FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
60  FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
61  FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
62  FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
63 
64  /* Round 2 */
65  GG(a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
66  GG(d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
67  GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
68  GG(b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
69  GG(a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
70  GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
71  GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
72  GG(b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
73  GG(a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
74  GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
75  GG(c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
76  GG(b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
77  GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
78  GG(d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
79  GG(c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
80  GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
81 
82  /* Round 3 */
83  HH(a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
84  HH(d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
85  HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
86  HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
87  HH(a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
88  HH(d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
89  HH(c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
90  HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
91  HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
92  HH(d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
93  HH(c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
94  HH(b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
95  HH(a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
96  HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
97  HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
98  HH(b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
99 
100  /* Round 4 */
101  II(a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
102  II(d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
103  II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
104  II(b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
105  II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
106  II(d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
107  II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
108  II(b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
109  II(a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
110  II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
111  II(c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
112  II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
113  II(a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
114  II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
115  II(c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
116  II(b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
117 
118  state[0]+=a;
119  state[1]+=b;
120  state[2]+=c;
121  state[3]+=d;
122 
123  // Zeroize sensitive information.
124  MemSet((uint1*)x, 0, sizeof(x));
125 }
#define IAssert(Cond)
Definition: bd.h:262
TB4Def::TB4 uint4
Definition: md5.h:8
static void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
Definition: md5.h:40
static void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
Definition: md5.h:44
uint4 state[4]
Definition: md5.h:13
static void Decode(uint4 *Dst, uint1 *Src, uint4 Len)
Definition: md5.cpp:140
TB1Def::TB1 uint1
Definition: md5.h:10
static void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
Definition: md5.h:38
static void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
Definition: md5.h:42
static void MemSet(uint1 *Start, uint1 Val, uint4 Len)
Definition: md5.h:26
bool DefP
Definition: md5.h:17
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: