C++常用的md5类

2011/10/18 技术文章 0 Comment 11,782 Views

使用代码

string c,key;
cin &gt;&gt; c;
if( c == &quot;c&quot; ) return(0);
CMD5 iMD5;
iMD5.GenerateMD5( (unsigned char*)c.c_str(), c.size() );
key = iMD5.ToString();

string c,key;

cin >> c;

if( c == "c" ) return(0);

CMD5 iMD5;

iMD5.GenerateMD5( (unsigned char*)c.c_str(), c.size() );

key = iMD5.ToString();

Md5.h

#ifndef _MD5_H
#define _MD5_H

//#pragma warning(disable:4786)

#include &lt;string&gt;

using namespace std;

/*!
* Manage MD5.
*/
class CMD5
{
private:
#define uint8 unsigned char
#define uint32 unsigned long int

struct md5_context
{
   uint32 total[2];
   uint32 state[4];
   uint8 buffer[64];
};

void md5_starts( struct md5_context *ctx );
void md5_process( struct md5_context *ctx, uint8 data[64] );
void md5_update( struct md5_context *ctx, uint8 *input, uint32 length );
void md5_finish( struct md5_context *ctx, uint8 digest[16] );

public:
//! construct a CMD5 from any buffer
void GenerateMD5(unsigned char* buffer,int bufferlen);

//! construct a CMD5
CMD5();

//! construct a md5src from char *
CMD5(const char * md5src);

//! construct a CMD5 from a 16 bytes md5
CMD5(unsigned long* md5src);

//! add a other md5
CMD5 operator +(CMD5 adder);

//! just if equal
bool operator ==(CMD5 cmper);

//! give the value from equer
// void operator =(CMD5 equer);

//! to a string
string ToString();

unsigned long m_data[4];
};
#endif /* md5.h */

#ifndef _MD5_H

#define _MD5_H

//#pragma warning(disable:4786)

#include <string>

using namespace std;

/*!

* Manage MD5.

class CMD5

{

private:

#define uint8 unsigned char

#define uint32 unsigned long int

struct md5_context

{

uint32 total[2];

uint32 state[4];

uint8 buffer[64];

};

void md5_starts( struct md5_context *ctx );

void md5_process( struct md5_context *ctx, uint8 data[64] );

void md5_update( struct md5_context *ctx, uint8 *input, uint32 length );

void md5_finish( struct md5_context *ctx, uint8 digest[16] );

public:

//! construct a CMD5 from any buffer

void GenerateMD5(unsigned char* buffer,int bufferlen);

//! construct a CMD5

CMD5();

//! construct a md5src from char *

CMD5(const char * md5src);

//! construct a CMD5 from a 16 bytes md5

CMD5(unsigned long* md5src);

//! add a other md5

CMD5 operator +(CMD5 adder);

//! just if equal

bool operator ==(CMD5 cmper);

//! give the value from equer

// void operator =(CMD5 equer);

//! to a string

string ToString();

unsigned long m_data[4];

};

#endif /* md5.h */

Md5.cpp

/*
* RFC 1321 compliant MD5 implementation,
* by Christophe Devine &lt;devine@cr0.net&gt;;
* this program is licensed under the GPL.
*/
#include &quot;Md5.h&quot;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt; 

#define GET_UINT32(n,b,i)                                       \
{                                                               \
    (n) = (uint32) ((uint8 *) b)[(i)]                           \
      | (((uint32) ((uint8 *) b)[(i)+1]) &lt;&lt; 8 )                 \
      | (((uint32) ((uint8 *) b)[(i)+2]) &lt;&lt; 16)                 \
      | (((uint32) ((uint8 *) b)[(i)+3]) &lt;&lt; 24);                \
} 

#define PUT_UINT32(n,b,i)                                       \
{                                                               \
    (((uint8 *) b)[(i)] ) = (uint8) (((n)      ) &amp; 0xFF);      \
    (((uint8 *) b)[(i)+1]) = (uint8) (((n) &gt;&gt; 8 ) &amp; 0xFF);      \
    (((uint8 *) b)[(i)+2]) = (uint8) (((n) &gt;&gt; 16) &amp; 0xFF);      \
    (((uint8 *) b)[(i)+3]) = (uint8) (((n) &gt;&gt; 24) &amp; 0xFF);      \
} 

//extern pthread_mutex_t mutexMemory; 

void CMD5::md5_starts( struct md5_context *ctx )
{
    ctx-&gt;total[0] = 0;
    ctx-&gt;total[1] = 0;
    ctx-&gt;state[0] = 0x67452301;
    ctx-&gt;state[1] = 0xEFCDAB89;
    ctx-&gt;state[2] = 0x98BADCFE;
    ctx-&gt;state[3] = 0x10325476;
} 

void CMD5::md5_process( struct md5_context *ctx, uint8 data[64] )
{
    uint32 A, B, C, D, X[16]; 

    GET_UINT32( X[0], data, 0 );
    GET_UINT32( X[1], data, 4 );
    GET_UINT32( X[2], data, 8 );
    GET_UINT32( X[3], data, 12 );
    GET_UINT32( X[4], data, 16 );
    GET_UINT32( X[5], data, 20 );
    GET_UINT32( X[6], data, 24 );
    GET_UINT32( X[7], data, 28 );
    GET_UINT32( X[8], data, 32 );
    GET_UINT32( X[9], data, 36 );
    GET_UINT32( X[10], data, 40 );
    GET_UINT32( X[11], data, 44 );
    GET_UINT32( X[12], data, 48 );
    GET_UINT32( X[13], data, 52 );
    GET_UINT32( X[14], data, 56 );
    GET_UINT32( X[15], data, 60 ); 

#define S(x,n) ((x &lt;&lt; n) | ((x &amp; 0xFFFFFFFF) &gt;&gt; (32 - n))) 

#define P(a,b,c,d,k,s,t)                                \
{                                                       \
    a += F(b,c,d) + X[k] + t; a = S(a,s) + b;           \
} 

    A = ctx-&gt;state[0];
    B = ctx-&gt;state[1];
    C = ctx-&gt;state[2];
    D = ctx-&gt;state[3]; 

#define F(x,y,z) (z ^ (x &amp; (y ^ z))) 

    P( A, B, C, D, 0, 7, 0xD76AA478 );
    P( D, A, B, C, 1, 12, 0xE8C7B756 );
    P( C, D, A, B, 2, 17, 0x242070DB );
    P( B, C, D, A, 3, 22, 0xC1BDCEEE );
    P( A, B, C, D, 4, 7, 0xF57C0FAF );
    P( D, A, B, C, 5, 12, 0x4787C62A );
    P( C, D, A, B, 6, 17, 0xA8304613 );
    P( B, C, D, A, 7, 22, 0xFD469501 );
    P( A, B, C, D, 8, 7, 0x698098D8 );
    P( D, A, B, C, 9, 12, 0x8B44F7AF );
    P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
    P( B, C, D, A, 11, 22, 0x895CD7BE );
    P( A, B, C, D, 12, 7, 0x6B901122 );
    P( D, A, B, C, 13, 12, 0xFD987193 );
    P( C, D, A, B, 14, 17, 0xA679438E );
    P( B, C, D, A, 15, 22, 0x49B40821 ); 

#undef F 

#define F(x,y,z) (y ^ (z &amp; (x ^ y))) 

    P( A, B, C, D, 1, 5, 0xF61E2562 );
    P( D, A, B, C, 6, 9, 0xC040B340 );
    P( C, D, A, B, 11, 14, 0x265E5A51 );
    P( B, C, D, A, 0, 20, 0xE9B6C7AA );
    P( A, B, C, D, 5, 5, 0xD62F105D );
    P( D, A, B, C, 10, 9, 0x02441453 );
    P( C, D, A, B, 15, 14, 0xD8A1E681 );
    P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
    P( A, B, C, D, 9, 5, 0x21E1CDE6 );
    P( D, A, B, C, 14, 9, 0xC33707D6 );
    P( C, D, A, B, 3, 14, 0xF4D50D87 );
    P( B, C, D, A, 8, 20, 0x455A14ED );
    P( A, B, C, D, 13, 5, 0xA9E3E905 );
    P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
    P( C, D, A, B, 7, 14, 0x676F02D9 );
    P( B, C, D, A, 12, 20, 0x8D2A4C8A ); 

#undef F 

#define F(x,y,z) (x ^ y ^ z) 

    P( A, B, C, D, 5, 4, 0xFFFA3942 );
    P( D, A, B, C, 8, 11, 0x8771F681 );
    P( C, D, A, B, 11, 16, 0x6D9D6122 );
    P( B, C, D, A, 14, 23, 0xFDE5380C );
    P( A, B, C, D, 1, 4, 0xA4BEEA44 );
    P( D, A, B, C, 4, 11, 0x4BDECFA9 );
    P( C, D, A, B, 7, 16, 0xF6BB4B60 );
    P( B, C, D, A, 10, 23, 0xBEBFBC70 );
    P( A, B, C, D, 13, 4, 0x289B7EC6 );
    P( D, A, B, C, 0, 11, 0xEAA127FA );
    P( C, D, A, B, 3, 16, 0xD4EF3085 );
    P( B, C, D, A, 6, 23, 0x04881D05 );
    P( A, B, C, D, 9, 4, 0xD9D4D039 );
    P( D, A, B, C, 12, 11, 0xE6DB99E5 );
    P( C, D, A, B, 15, 16, 0x1FA27CF8 );
    P( B, C, D, A, 2, 23, 0xC4AC5665 ); 

#undef F 

#define F(x,y,z) (y ^ (x | ~z)) 

    P( A, B, C, D, 0, 6, 0xF4292244 );
    P( D, A, B, C, 7, 10, 0x432AFF97 );
    P( C, D, A, B, 14, 15, 0xAB9423A7 );
    P( B, C, D, A, 5, 21, 0xFC93A039 );
    P( A, B, C, D, 12, 6, 0x655B59C3 );
    P( D, A, B, C, 3, 10, 0x8F0CCC92 );
    P( C, D, A, B, 10, 15, 0xFFEFF47D );
    P( B, C, D, A, 1, 21, 0x85845DD1 );
    P( A, B, C, D, 8, 6, 0x6FA87E4F );
    P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
    P( C, D, A, B, 6, 15, 0xA3014314 );
    P( B, C, D, A, 13, 21, 0x4E0811A1 );
    P( A, B, C, D, 4, 6, 0xF7537E82 );
    P( D, A, B, C, 11, 10, 0xBD3AF235 );
    P( C, D, A, B, 2, 15, 0x2AD7D2BB );
    P( B, C, D, A, 9, 21, 0xEB86D391 ); 

#undef F 

    ctx-&gt;state[0] += A;
    ctx-&gt;state[1] += B;
    ctx-&gt;state[2] += C;
    ctx-&gt;state[3] += D;
} 

void CMD5::md5_update( struct md5_context *ctx, uint8 *input, uint32 length )
{
    uint32 left, fill; 

    if( ! length ) return; 

    left = ( ctx-&gt;total[0] &gt;&gt; 3 ) &amp; 0x3F;
    fill = 64 - left; 

    ctx-&gt;total[0] += length &lt;&lt; 3;
    ctx-&gt;total[1] += length &gt;&gt; 29; 

    ctx-&gt;total[0] &amp;= 0xFFFFFFFF;
    ctx-&gt;total[1] += ctx-&gt;total[0] &lt; length &lt;&lt; 3; 

    if( left &amp;&amp; length &gt;= fill )
    {
        memcpy( (void *) (ctx-&gt;buffer + left), (void *) input, fill );
        md5_process( ctx, ctx-&gt;buffer );
        length -= fill;
        input += fill;
        left = 0;
    } 

    while( length &gt;= 64 )
    {
        md5_process( ctx, input );
        length -= 64;
        input += 64;
    } 

    if( length )
    {
        memcpy( (void *) (ctx-&gt;buffer + left), (void *) input, length );
    }
} 

static uint8 md5_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
}; 

void CMD5::md5_finish( struct md5_context *ctx, uint8 digest[16] )
{
    uint32 last, padn;
    uint8 msglen[8]; 

    PUT_UINT32( ctx-&gt;total[0], msglen, 0 );
    PUT_UINT32( ctx-&gt;total[1], msglen, 4 ); 

    last = ( ctx-&gt;total[0] &gt;&gt; 3 ) &amp; 0x3F;
    padn = ( last &lt; 56 ) ? ( 56 - last ) : ( 120 - last ); 

    md5_update( ctx, md5_padding, padn );
    md5_update( ctx, msglen, 8 ); 

    PUT_UINT32( ctx-&gt;state[0], digest, 0 );
    PUT_UINT32( ctx-&gt;state[1], digest, 4 );
    PUT_UINT32( ctx-&gt;state[2], digest, 8 );
    PUT_UINT32( ctx-&gt;state[3], digest, 12 );
} 

void CMD5::GenerateMD5(unsigned char* buffer,int bufferlen)
{
    struct md5_context context;
    md5_starts (&amp;context);
    md5_update (&amp;context, buffer, bufferlen);
    md5_finish (&amp;context,(unsigned char*)m_data);
} 

CMD5::CMD5()
{
    for(int i=0;i&lt;4;i++)
        m_data[i]=0;
} 

CMD5::CMD5(unsigned long* md5src)
{
    memcpy(m_data,md5src,16);
}
int _httoi(const char *value)
{
struct CHexMap
{
    char chr;
    int value;
};
const int HexMapL = 16;
CHexMap HexMap[HexMapL] =
{
    {&#39;0&#39;, 0}, {&#39;1&#39;, 1},
    {&#39;2&#39;, 2}, {&#39;3&#39;, 3},
    {&#39;4&#39;, 4}, {&#39;5&#39;, 5},
    {&#39;6&#39;, 6}, {&#39;7&#39;, 7},
    {&#39;8&#39;, 8}, {&#39;9&#39;, 9},
    {&#39;a&#39;, 10}, {&#39;b&#39;, 11},
    {&#39;c&#39;, 12}, {&#39;d&#39;, 13},
    {&#39;e&#39;, 14}, {&#39;f&#39;, 15}
};
//pthread_mutex_lock(&amp;mutexMemory);
char *mstr = strdup(value);
//pthread_mutex_unlock(&amp;mutexMemory);
char *s = mstr;
int result = 0;
if (*s == &#39;0&#39; &amp;&amp; *(s + 1) == &#39;X&#39;) s += 2;
bool firsttime = true;
while (*s != &#39;\0&#39;)
{
    bool found = false;
    for (int i = 0; i &lt; HexMapL; i++)
    {
      if (*s == HexMap[i].chr)
      {
        if (!firsttime) result &lt;&lt;= 4;
        result |= HexMap[i].value;
        found = true;
        break;
      }
    }
    if (!found) break;
    s++;
    firsttime = false;
}
//pthread_mutex_lock(&amp;mutexMemory);
free(mstr);
//pthread_mutex_unlock(&amp;mutexMemory);
return result;
} 

CMD5::CMD5(const char* md5src)
{
    if (strcmp(md5src,&quot;&quot;)==0)
    {
        for(int i=0;i&lt;4;i++)
            m_data[i]=0;
        return;
    }
    for(int j = 0; j &lt; 16; j++ )
    {
        char buf[10];
        strncpy(buf,md5src,2);
        md5src+=2;
        ((unsigned char*)m_data)[j] = _httoi(buf);
    }
} 

CMD5 CMD5::operator +(CMD5 adder)
{
    unsigned long m_newdata[4];
    for(int i=0;i&lt;4;i++)
        m_newdata[i]=m_data[i]^(adder.m_data[i]);
    return CMD5(m_newdata);
} 

bool CMD5::operator ==(CMD5 cmper)
{
    return (memcmp(cmper.m_data ,m_data,16)==0);
} 

//void CMD5::operator =(CMD5 equer)
//{
// memcpy(m_data,equer.m_data ,16);
//} 

string CMD5::ToString()
{
    char output[33];
    for(int j = 0; j &lt; 16; j++ )
    {
        sprintf( output + j * 2, &quot;%02x&quot;, ((unsigned char*)m_data)[j]);
    }
    return string(output);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

* RFC 1321 compliant MD5 implementation,

* by Christophe Devine <devine@cr0.net>;

* this program is licensed under the GPL.

#include "Md5.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define GET_UINT32(n,b,i) \

{ \

(n) = (uint32) ((uint8 *) b)[(i)] \

| (((uint32) ((uint8 *) b)[(i)+1]) << 8 ) \

| (((uint32) ((uint8 *) b)[(i)+2]) << 16) \

| (((uint32) ((uint8 *) b)[(i)+3]) << 24); \

}

#define PUT_UINT32(n,b,i) \

{ \

(((uint8 *) b)[(i)] ) = (uint8) (((n) ) & 0xFF); \

(((uint8 *) b)[(i)+1]) = (uint8) (((n) >> 8 ) & 0xFF); \

(((uint8 *) b)[(i)+2]) = (uint8) (((n) >> 16) & 0xFF); \

(((uint8 *) b)[(i)+3]) = (uint8) (((n) >> 24) & 0xFF); \

}

//extern pthread_mutex_t mutexMemory;

void CMD5::md5_starts( struct md5_context *ctx )

{

ctx->total[0] = 0;

ctx->total[1] = 0;

ctx->state[0] = 0x67452301;

ctx->state[1] = 0xEFCDAB89;

ctx->state[2] = 0x98BADCFE;

ctx->state[3] = 0x10325476;

}

void CMD5::md5_process( struct md5_context *ctx, uint8 data[64] )

{

uint32 A, B, C, D, X[16];

GET_UINT32( X[0], data, 0 );

GET_UINT32( X[1], data, 4 );

GET_UINT32( X[2], data, 8 );

GET_UINT32( X[3], data, 12 );

GET_UINT32( X[4], data, 16 );

GET_UINT32( X[5], data, 20 );

GET_UINT32( X[6], data, 24 );

GET_UINT32( X[7], data, 28 );

GET_UINT32( X[8], data, 32 );

GET_UINT32( X[9], data, 36 );

GET_UINT32( X[10], data, 40 );

GET_UINT32( X[11], data, 44 );

GET_UINT32( X[12], data, 48 );

GET_UINT32( X[13], data, 52 );

GET_UINT32( X[14], data, 56 );

GET_UINT32( X[15], data, 60 );

#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))

#define P(a,b,c,d,k,s,t) \

{ \

a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \

}

A = ctx->state[0];

B = ctx->state[1];

C = ctx->state[2];

D = ctx->state[3];

#define F(x,y,z) (z ^ (x & (y ^ z)))

P( A, B, C, D, 0, 7, 0xD76AA478 );

P( D, A, B, C, 1, 12, 0xE8C7B756 );

P( C, D, A, B, 2, 17, 0x242070DB );

P( B, C, D, A, 3, 22, 0xC1BDCEEE );

P( A, B, C, D, 4, 7, 0xF57C0FAF );

P( D, A, B, C, 5, 12, 0x4787C62A );

P( C, D, A, B, 6, 17, 0xA8304613 );

P( B, C, D, A, 7, 22, 0xFD469501 );

P( A, B, C, D, 8, 7, 0x698098D8 );

P( D, A, B, C, 9, 12, 0x8B44F7AF );

P( C, D, A, B, 10, 17, 0xFFFF5BB1 );

P( B, C, D, A, 11, 22, 0x895CD7BE );

P( A, B, C, D, 12, 7, 0x6B901122 );

P( D, A, B, C, 13, 12, 0xFD987193 );

P( C, D, A, B, 14, 17, 0xA679438E );

P( B, C, D, A, 15, 22, 0x49B40821 );

#undef F

#define F(x,y,z) (y ^ (z & (x ^ y)))

P( A, B, C, D, 1, 5, 0xF61E2562 );

P( D, A, B, C, 6, 9, 0xC040B340 );

P( C, D, A, B, 11, 14, 0x265E5A51 );

P( B, C, D, A, 0, 20, 0xE9B6C7AA );

P( A, B, C, D, 5, 5, 0xD62F105D );

P( D, A, B, C, 10, 9, 0x02441453 );

P( C, D, A, B, 15, 14, 0xD8A1E681 );

P( B, C, D, A, 4, 20, 0xE7D3FBC8 );

P( A, B, C, D, 9, 5, 0x21E1CDE6 );

P( D, A, B, C, 14, 9, 0xC33707D6 );

P( C, D, A, B, 3, 14, 0xF4D50D87 );

P( B, C, D, A, 8, 20, 0x455A14ED );

P( A, B, C, D, 13, 5, 0xA9E3E905 );

P( D, A, B, C, 2, 9, 0xFCEFA3F8 );

P( C, D, A, B, 7, 14, 0x676F02D9 );

P( B, C, D, A, 12, 20, 0x8D2A4C8A );

#undef F

#define F(x,y,z) (x ^ y ^ z)

P( A, B, C, D, 5, 4, 0xFFFA3942 );

P( D, A, B, C, 8, 11, 0x8771F681 );

P( C, D, A, B, 11, 16, 0x6D9D6122 );

P( B, C, D, A, 14, 23, 0xFDE5380C );

P( A, B, C, D, 1, 4, 0xA4BEEA44 );

P( D, A, B, C, 4, 11, 0x4BDECFA9 );

P( C, D, A, B, 7, 16, 0xF6BB4B60 );

P( B, C, D, A, 10, 23, 0xBEBFBC70 );

P( A, B, C, D, 13, 4, 0x289B7EC6 );

P( D, A, B, C, 0, 11, 0xEAA127FA );

P( C, D, A, B, 3, 16, 0xD4EF3085 );

P( B, C, D, A, 6, 23, 0x04881D05 );

P( A, B, C, D, 9, 4, 0xD9D4D039 );

P( D, A, B, C, 12, 11, 0xE6DB99E5 );

P( C, D, A, B, 15, 16, 0x1FA27CF8 );

P( B, C, D, A, 2, 23, 0xC4AC5665 );

#undef F

#define F(x,y,z) (y ^ (x | ~z))

P( A, B, C, D, 0, 6, 0xF4292244 );

P( D, A, B, C, 7, 10, 0x432AFF97 );

P( C, D, A, B, 14, 15, 0xAB9423A7 );

P( B, C, D, A, 5, 21, 0xFC93A039 );

P( A, B, C, D, 12, 6, 0x655B59C3 );

P( D, A, B, C, 3, 10, 0x8F0CCC92 );

P( C, D, A, B, 10, 15, 0xFFEFF47D );

P( B, C, D, A, 1, 21, 0x85845DD1 );

P( A, B, C, D, 8, 6, 0x6FA87E4F );

P( D, A, B, C, 15, 10, 0xFE2CE6E0 );

P( C, D, A, B, 6, 15, 0xA3014314 );

P( B, C, D, A, 13, 21, 0x4E0811A1 );

P( A, B, C, D, 4, 6, 0xF7537E82 );

P( D, A, B, C, 11, 10, 0xBD3AF235 );

P( C, D, A, B, 2, 15, 0x2AD7D2BB );

P( B, C, D, A, 9, 21, 0xEB86D391 );

#undef F

ctx->state[0] += A;

ctx->state[1] += B;

ctx->state[2] += C;

ctx->state[3] += D;

}

void CMD5::md5_update( struct md5_context *ctx, uint8 *input, uint32 length )

{

uint32 left, fill;

if( ! length ) return;

left = ( ctx->total[0] >> 3 ) & 0x3F;

fill = 64 - left;

ctx->total[0] += length << 3;

ctx->total[1] += length >> 29;

ctx->total[0] &= 0xFFFFFFFF;

ctx->total[1] += ctx->total[0] < length << 3;

if( left && length >= fill )

{

memcpy( (void *) (ctx->buffer + left), (void *) input, fill );

md5_process( ctx, ctx->buffer );

length -= fill;

input += fill;

left = 0;

}

while( length >= 64 )

{

md5_process( ctx, input );

length -= 64;

input += 64;

}

if( length )

{

memcpy( (void *) (ctx->buffer + left), (void *) input, length );

}

static uint8 md5_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

};

void CMD5::md5_finish( struct md5_context *ctx, uint8 digest[16] )

{

uint32 last, padn;

uint8 msglen[8];

PUT_UINT32( ctx->total[0], msglen, 0 );

PUT_UINT32( ctx->total[1], msglen, 4 );

last = ( ctx->total[0] >> 3 ) & 0x3F;

padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );

md5_update( ctx, md5_padding, padn );

md5_update( ctx, msglen, 8 );

PUT_UINT32( ctx->state[0], digest, 0 );

PUT_UINT32( ctx->state[1], digest, 4 );

PUT_UINT32( ctx->state[2], digest, 8 );

PUT_UINT32( ctx->state[3], digest, 12 );

}

void CMD5::GenerateMD5(unsigned char* buffer,int bufferlen)

{

struct md5_context context;

md5_starts (&context);

md5_update (&context, buffer, bufferlen);

md5_finish (&context,(unsigned char*)m_data);

}

CMD5::CMD5()

{

for(int i=0;i<4;i++)

m_data[i]=0;

}

CMD5::CMD5(unsigned long* md5src)

{

memcpy(m_data,md5src,16);

}

int _httoi(const char *value)

{

struct CHexMap

{

char chr;

int value;

};

const int HexMapL = 16;

CHexMap HexMap[HexMapL] =

{

{'0', 0}, {'1', 1},

{'2', 2}, {'3', 3},

{'4', 4}, {'5', 5},

{'6', 6}, {'7', 7},

{'8', 8}, {'9', 9},

{'a', 10}, {'b', 11},

{'c', 12}, {'d', 13},

{'e', 14}, {'f', 15}

};

//pthread_mutex_lock(&mutexMemory);

char *mstr = strdup(value);

//pthread_mutex_unlock(&mutexMemory);

char *s = mstr;

int result = 0;

if (*s == '0' && *(s + 1) == 'X') s += 2;

bool firsttime = true;

while (*s != '\0')

{

bool found = false;

for (int i = 0; i < HexMapL; i++)

{

if (*s == HexMap[i].chr)

{

if (!firsttime) result <<= 4;

result |= HexMap[i].value;

found = true;

break;

}

if (!found) break;

s++;

firsttime = false;

}

//pthread_mutex_lock(&mutexMemory);

free(mstr);

//pthread_mutex_unlock(&mutexMemory);

return result;

}

CMD5::CMD5(const char* md5src)

{

if (strcmp(md5src,"")==0)

{

for(int i=0;i<4;i++)

m_data[i]=0;

return;

}

for(int j = 0; j < 16; j++ )

{

char buf[10];

strncpy(buf,md5src,2);

md5src+=2;

((unsigned char*)m_data)[j] = _httoi(buf);

}

CMD5 CMD5::operator +(CMD5 adder)

{

unsigned long m_newdata[4];

for(int i=0;i<4;i++)

m_newdata[i]=m_data[i]^(adder.m_data[i]);

return CMD5(m_newdata);

}

bool CMD5::operator ==(CMD5 cmper)

{

return (memcmp(cmper.m_data ,m_data,16)==0);

}

//void CMD5::operator =(CMD5 equer)

//{

// memcpy(m_data,equer.m_data ,16);

//}

string CMD5::ToString()

{

char output[33];

for(int j = 0; j < 16; j++ )

{

sprintf( output + j * 2, "%02x", ((unsigned char*)m_data)[j]);

}

return string(output);

}

郑重声明：
除特别声明为转载内容外，本站所有内容均为作者原创，谢绝任何单位和个人不经许可的复制和转播！
对于确有转载需要的，请先与作者联系，在获得允许后烦请在转载时保留文章出处。
本文出自Lupin's Blog：http://www.cnzui.com/archives/328

你是否也喜欢以下相关日志？

C++开源跨平台类库集在如下的库支持下，开发的系统可以很方便移植到当前大部分平台上运行而无需改动 […]
InstallShield12制作OCX或DLL安装包时碰到的问题最近用InstallShield12作了一个安装包，遇到一些新手问题，在 […]
C#中运行时表达式(类似js的eval)的实现实现这个功能的主要思路是: 编译->生成程序集->反射调用 […]
VS插件项目Failed to retrieve paths under VSTemplate for the specified registry hive. 这些天在开发IDE插件时，一开始不知道怎么重置IDE调试环境，于是自己在 […]
wxWidgets使用ADO访问数据库时遇到的编译问题今天在做项目的时候，遇到一个非常郁闷的问题，捣鼓了半天，最后在国外的一个 […]

你是否也喜欢以下相关日志？

获取我的最新消息？