1
<HTML>
2
3
<HEAD>
4
5
<META http-equiv='Content-Type' content='text/html; charset=gb2312'>
6
7
<TITLE>非常流行的JS的md5加密办法</TITLE>
8
9
</HEAD>
10
11
<BODY >
12
13
14
15
<input id=test value=webasp>
16
17
<input type=button value=md5 onclick="alert(hex_md5(test.value))">
18
19
20
21
<script>
22
23
var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */
24
25
var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */
26
27
var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */
28
29
30
31
/*
32
33
* These are the functions you'll usually want to call
34
35
* They take string arguments and return either hex or base-64 encoded strings
36
37
*/
38
39
function hex_md5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
40
41
function b64_md5(s){ return binl2b64(core_md5(str2binl(s), s.length * chrsz));}
42
43
function hex_hmac_md5(key, data) { return binl2hex(core_hmac_md5(key, data)); }
44
45
function b64_hmac_md5(key, data) { return binl2b64(core_hmac_md5(key, data)); }
46
47
48
49
/* Backwards compatibility - same as hex_md5() */
50
51
function calcMD5(s){ return binl2hex(core_md5(str2binl(s), s.length * chrsz));}
52
53
54
55
/*
56
57
* Perform a simple self-test to see if the VM is working
58
59
*/
60
61
function md5_vm_test()
62
63
{
64
65
return hex_md5("abc") == "900150983cd24fb0d6963f7d28e17f72";
66
67
}
68
69
70
71
/*
72
73
* Calculate the MD5 of an array of little-endian words, and a bit length
74
75
*/
76
77
function core_md5(x, len)
78
79
{
80
81
/* append padding */
82
83
x[len >> 5] |= 0x80 << ((len) % 32);
84
85
x[(((len + 64) >>> 9) << 4) + 14] = len;
86
87
88
89
var a = 1732584193;
90
91
var b = -271733879;
92
93
var c = -1732584194;
94
95
var d = 271733878;
96
97
98
99
for(var i = 0; i < x.length; i += 16)
100
101
{
102
103
var olda = a;
104
105
var oldb = b;
106
107
var oldc = c;
108
109
var oldd = d;
110
111
112
113
a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);
114
115
d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);
116
117
c = md5_ff(c, d, a, b, x[i+ 2], 17, 606105819);
118
119
b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);
120
121
a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);
122
123
d = md5_ff(d, a, b, c, x[i+ 5], 12, 1200080426);
124
125
c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);
126
127
b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);
128
129
a = md5_ff(a, b, c, d, x[i+ 8], 7 , 1770035416);
130
131
d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);
132
133
c = md5_ff(c, d, a, b, x[i+10], 17, -42063);
134
135
b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);
136
137
a = md5_ff(a, b, c, d, x[i+12], 7 , 1804603682);
138
139
d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);
140
141
c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);
142
143
b = md5_ff(b, c, d, a, x[i+15], 22, 1236535329);
144
145
146
147
a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);
148
149
d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
150
151
c = md5_gg(c, d, a, b, x[i+11], 14, 643717713);
152
153
b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);
154
155
a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);
156
157
d = md5_gg(d, a, b, c, x[i+10], 9 , 38016083);
158
159
c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);
160
161
b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);
162
163
a = md5_gg(a, b, c, d, x[i+ 9], 5 , 568446438);
164
165
d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);
166
167
c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);
168
169
b = md5_gg(b, c, d, a, x[i+ 8], 20, 1163531501);
170
171
a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);
172
173
d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);
174
175
c = md5_gg(c, d, a, b, x[i+ 7], 14, 1735328473);
176
177
b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);
178
179
180
181
a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);
182
183
d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);
184
185
c = md5_hh(c, d, a, b, x[i+11], 16, 1839030562);
186
187
b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);
188
189
a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
190
191
d = md5_hh(d, a, b, c, x[i+ 4], 11, 1272893353);
192
193
c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);
194
195
b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);
196
197
a = md5_hh(a, b, c, d, x[i+13], 4 , 681279174);
198
199
d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);
200
201
c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);
202
203
b = md5_hh(b, c, d, a, x[i+ 6], 23, 76029189);
204
205
a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);
206
207
d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);
208
209
c = md5_hh(c, d, a, b, x[i+15], 16, 530742520);
210
211
b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);
212
213
214
215
a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);
216
217
d = md5_ii(d, a, b, c, x[i+ 7], 10, 1126891415);
218
219
c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);
220
221
b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);
222
223
a = md5_ii(a, b, c, d, x[i+12], 6 , 1700485571);
224
225
d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);
226
227
c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);
228
229
b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);
230
231
a = md5_ii(a, b, c, d, x[i+ 8], 6 , 1873313359);
232
233
d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);
234
235
c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);
236
237
b = md5_ii(b, c, d, a, x[i+13], 21, 1309151649);
238
239
a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);
240
241
d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);
242
243
c = md5_ii(c, d, a, b, x[i+ 2], 15, 718787259);
244
245
b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);
246
247
248
249
a = safe_add(a, olda);
250
251
b = safe_add(b, oldb);
252
253
c = safe_add(c, oldc);
254
255
d = safe_add(d, oldd);
256
257
}
258
259
return Array(a, b, c, d);
260
261
262
263
}
264
265
266
267
/*
268
269
* These functions implement the four basic operations the algorithm uses.
270
271
*/
272
273
function md5_cmn(q, a, b, x, s, t)
274
275
{
276
277
return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);
278
279
}
280
281
function md5_ff(a, b, c, d, x, s, t)
282
283
{
284
285
return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);
286
287
}
288
289
function md5_gg(a, b, c, d, x, s, t)
290
291
{
292
293
return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);
294
295
}
296
297
function md5_hh(a, b, c, d, x, s, t)
298
299
{
300
301
return md5_cmn(b ^ c ^ d, a, b, x, s, t);
302
303
}
304
305
function md5_ii(a, b, c, d, x, s, t)
306
307
{
308
309
return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);
310
311
}
312
313
314
315
/*
316
317
* Calculate the HMAC-MD5, of a key and some data
318
319
*/
320
321
function core_hmac_md5(key, data)
322
323
{
324
325
var bkey = str2binl(key);
326
327
if(bkey.length > 16) bkey = core_md5(bkey, key.length * chrsz);
328
329
330
331
var ipad = Array(16), opad = Array(16);
332
333
for(var i = 0; i < 16; i++)
334
335
{
336
337
ipad[i] = bkey[i] ^ 0x36363636;
338
339
opad[i] = bkey[i] ^ 0x5C5C5C5C;
340
341
}
342
343
344
345
var hash = core_md5(ipad.concat(str2binl(data)), 512 + data.length * chrsz);
346
347
return core_md5(opad.concat(hash), 512 + 128);
348
349
}
350
351
352
353
/*
354
355
* Add integers, wrapping at 2^32. This uses 16-bit operations internally
356
357
* to work around bugs in some JS interpreters.
358
359
*/
360
361
function safe_add(x, y)
362
363
{
364
365
var lsw = (x & 0xFFFF) + (y & 0xFFFF);
366
367
var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
368
369
return (msw << 16) | (lsw & 0xFFFF);
370
371
}
372
373
374
375
/*
376
377
* Bitwise rotate a 32-bit number to the left.
378
379
*/
380
381
function bit_rol(num, cnt)
382
383
{
384
385
return (num << cnt) | (num >>> (32 - cnt));
386
387
}
388
389
390
391
/*
392
393
* Convert a string to an array of little-endian words
394
395
* If chrsz is ASCII, characters >255 have their hi-byte silently ignored.
396
397
*/
398
399
function str2binl(str)
400
401
{
402
403
var bin = Array();
404
405
var mask = (1 << chrsz) - 1;
406
407
for(var i = 0; i < str.length * chrsz; i += chrsz)
408
409
bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (i%32);
410
411
return bin;
412
413
}
414
415
416
417
/*
418
419
* Convert an array of little-endian words to a hex string.
420
421
*/
422
423
function binl2hex(binarray)
424
425
{
426
427
var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
428
429
var str = "";
430
431
for(var i = 0; i < binarray.length * 4; i++)
432
433
{
434
435
str += hex_tab.charAt((binarray[i>>2] >> ((i%4)*8+4)) & 0xF) +
436
437
hex_tab.charAt((binarray[i>>2] >> ((i%4)*8 )) & 0xF);
438
439
}
440
441
return str;
442
443
}
444
445
446
447
/*
448
449
* Convert an array of little-endian words to a base-64 string
450
451
*/
452
453
function binl2b64(binarray)
454
455
{
456
457
var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
458
459
var str = "";
460
461
for(var i = 0; i < binarray.length * 4; i += 3)
462
463
{
464
465
var triplet = (((binarray[i >> 2] >> 8 * ( i %4)) & 0xFF) << 16)
466
467
| (((binarray[i+1 >> 2] >> 8 * ((i+1)%4)) & 0xFF) << 8 )
468
469
| ((binarray[i+2 >> 2] >> 8 * ((i+2)%4)) & 0xFF);
470
471
for(var j = 0; j < 4; j++)
472
473
{
474
475
if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
476
477
else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
478
479
}
480
481
}
482
483
return str;
484
485
}
486
487
</script>
488
489
490
491
</BODY></HTML>
492

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

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

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492
