| 1 |
// Copyright 2011 The Closure Library Authors. All Rights Reserved. |
| 2 |
// |
| 3 |
// Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 |
// you may not use this file except in compliance with the License. |
| 5 |
// You may obtain a copy of the License at |
| 6 |
// |
| 7 |
// http://www.apache.org/licenses/LICENSE-2.0 |
| 8 |
// |
| 9 |
// Unless required by applicable law or agreed to in writing, software |
| 10 |
// distributed under the License is distributed on an "AS-IS" BASIS, |
| 11 |
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 |
// See the License for the specific language governing permissions and |
| 13 |
// limitations under the License. |
| 14 |
|
| 15 |
/** |
| 16 |
* @fileoverview MD5 cryptographic hash. |
| 17 |
* Implementation of http://tools.ietf.org/html/rfc1321 with common |
| 18 |
* optimizations and tweaks (see http://en.wikipedia.org/wiki/MD5). |
| 19 |
* |
| 20 |
* Usage: |
| 21 |
* var md5 = new goog.crypt.Md5(); |
| 22 |
* md5.update(bytes); |
| 23 |
* var hash = md5.digest(); |
| 24 |
* |
| 25 |
* Performance: |
| 26 |
* Chrome 23 ~680 Mbit/s |
| 27 |
* Chrome 13 (in a VM) ~250 Mbit/s |
| 28 |
* Firefox 6.0 (in a VM) ~100 Mbit/s |
| 29 |
* IE9 (in a VM) ~27 Mbit/s |
| 30 |
* Firefox 3.6 ~15 Mbit/s |
| 31 |
* IE8 (in a VM) ~13 Mbit/s |
| 32 |
* |
| 33 |
*/ |
| 34 |
|
| 35 |
goog.provide('goog.crypt.Md5'); |
| 36 |
|
| 37 |
goog.require('goog.crypt.Hash'); |
| 38 |
|
| 39 |
|
| 40 |
|
| 41 |
/** |
| 42 |
* MD5 cryptographic hash constructor. |
| 43 |
* @constructor |
| 44 |
* @extends {goog.crypt.Hash} |
| 45 |
* @final |
| 46 |
* @struct |
| 47 |
*/ |
| 48 |
goog.crypt.Md5 = function() { |
| 49 |
goog.crypt.Md5.base(this, 'constructor'); |
| 50 |
|
| 51 |
this.blockSize = 512 / 8; |
| 52 |
|
| 53 |
/** |
| 54 |
* Holds the current values of accumulated A-D variables (MD buffer). |
| 55 |
* @type {!Array<number>} |
| 56 |
* @private |
| 57 |
*/ |
| 58 |
this.chain_ = new Array(4); |
| 59 |
|
| 60 |
/** |
| 61 |
* A buffer holding the data until the whole block can be processed. |
| 62 |
* @type {!Array<number>} |
| 63 |
* @private |
| 64 |
*/ |
| 65 |
this.block_ = new Array(this.blockSize); |
| 66 |
|
| 67 |
/** |
| 68 |
* The length of yet-unprocessed data as collected in the block. |
| 69 |
* @type {number} |
| 70 |
* @private |
| 71 |
*/ |
| 72 |
this.blockLength_ = 0; |
| 73 |
|
| 74 |
/** |
| 75 |
* The total length of the message so far. |
| 76 |
* @type {number} |
| 77 |
* @private |
| 78 |
*/ |
| 79 |
this.totalLength_ = 0; |
| 80 |
|
| 81 |
this.reset(); |
| 82 |
}; |
| 83 |
goog.inherits(goog.crypt.Md5, goog.crypt.Hash); |
| 84 |
|
| 85 |
|
| 86 |
/** |
| 87 |
* Integer rotation constants used by the abbreviated implementation. |
| 88 |
* They are hardcoded in the unrolled implementation, so it is left |
| 89 |
* here commented out. |
| 90 |
* @type {Array<number>} |
| 91 |
* @private |
| 92 |
* |
| 93 |
goog.crypt.Md5.S_ = [ |
| 94 |
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, |
| 95 |
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, |
| 96 |
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, |
| 97 |
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 |
| 98 |
]; |
| 99 |
*/ |
| 100 |
|
| 101 |
/** |
| 102 |
* Sine function constants used by the abbreviated implementation. |
| 103 |
* They are hardcoded in the unrolled implementation, so it is left |
| 104 |
* here commented out. |
| 105 |
* @type {Array<number>} |
| 106 |
* @private |
| 107 |
* |
| 108 |
goog.crypt.Md5.T_ = [ |
| 109 |
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, |
| 110 |
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, |
| 111 |
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, |
| 112 |
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, |
| 113 |
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, |
| 114 |
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, |
| 115 |
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, |
| 116 |
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, |
| 117 |
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, |
| 118 |
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, |
| 119 |
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, |
| 120 |
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, |
| 121 |
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, |
| 122 |
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, |
| 123 |
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, |
| 124 |
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 |
| 125 |
]; |
| 126 |
*/ |
| 127 |
|
| 128 |
|
| 129 |
/** @override */ |
| 130 |
goog.crypt.Md5.prototype.reset = function() { |
| 131 |
this.chain_[0] = 0x67452301; |
| 132 |
this.chain_[1] = 0xefcdab89; |
| 133 |
this.chain_[2] = 0x98badcfe; |
| 134 |
this.chain_[3] = 0x10325476; |
| 135 |
|
| 136 |
this.blockLength_ = 0; |
| 137 |
this.totalLength_ = 0; |
| 138 |
}; |
| 139 |
|
| 140 |
|
| 141 |
/** |
| 142 |
* Internal compress helper function. It takes a block of data (64 bytes) |
| 143 |
* and updates the accumulator. |
| 144 |
* @param {Array<number>|Uint8Array|string} buf The block to compress. |
| 145 |
* @param {number=} opt_offset Offset of the block in the buffer. |
| 146 |
* @private |
| 147 |
*/ |
| 148 |
goog.crypt.Md5.prototype.compress_ = function(buf, opt_offset) { |
| 149 |
if (!opt_offset) { |
| 150 |
opt_offset = 0; |
| 151 |
} |
| 152 |
|
| 153 |
// We allocate the array every time, but it's cheap in practice. |
| 154 |
var X = new Array(16); |
| 155 |
|
| 156 |
// Get 16 little endian words. It is not worth unrolling this for Chrome 11. |
| 157 |
if (goog.isString(buf)) { |
| 158 |
for (var i = 0; i < 16; ++i) { |
| 159 |
X[i] = (buf.charCodeAt(opt_offset++)) | |
| 160 |
(buf.charCodeAt(opt_offset++) << 8) | |
| 161 |
(buf.charCodeAt(opt_offset++) << 16) | |
| 162 |
(buf.charCodeAt(opt_offset++) << 24); |
| 163 |
} |
| 164 |
} else { |
| 165 |
for (var i = 0; i < 16; ++i) { |
| 166 |
X[i] = (buf[opt_offset++]) | (buf[opt_offset++] << 8) | |
| 167 |
(buf[opt_offset++] << 16) | (buf[opt_offset++] << 24); |
| 168 |
} |
| 169 |
} |
| 170 |
|
| 171 |
var A = this.chain_[0]; |
| 172 |
var B = this.chain_[1]; |
| 173 |
var C = this.chain_[2]; |
| 174 |
var D = this.chain_[3]; |
| 175 |
var sum = 0; |
| 176 |
|
| 177 |
/* |
| 178 |
* This is an abbreviated implementation, it is left here commented out for |
| 179 |
* reference purposes. See below for an unrolled version in use. |
| 180 |
* |
| 181 |
var f, n, tmp; |
| 182 |
for (var i = 0; i < 64; ++i) { |
| 183 |
|
| 184 |
if (i < 16) { |
| 185 |
f = (D ^ (B & (C ^ D))); |
| 186 |
n = i; |
| 187 |
} else if (i < 32) { |
| 188 |
f = (C ^ (D & (B ^ C))); |
| 189 |
n = (5 * i + 1) % 16; |
| 190 |
} else if (i < 48) { |
| 191 |
f = (B ^ C ^ D); |
| 192 |
n = (3 * i + 5) % 16; |
| 193 |
} else { |
| 194 |
f = (C ^ (B | (~D))); |
| 195 |
n = (7 * i) % 16; |
| 196 |
} |
| 197 |
|
| 198 |
tmp = D; |
| 199 |
D = C; |
| 200 |
C = B; |
| 201 |
sum = (A + f + goog.crypt.Md5.T_[i] + X[n]) & 0xffffffff; |
| 202 |
B += ((sum << goog.crypt.Md5.S_[i]) & 0xffffffff) | |
| 203 |
(sum >>> (32 - goog.crypt.Md5.S_[i])); |
| 204 |
A = tmp; |
| 205 |
} |
| 206 |
*/ |
| 207 |
|
| 208 |
/* |
| 209 |
* This is an unrolled MD5 implementation, which gives ~30% speedup compared |
| 210 |
* to the abbreviated implementation above, as measured on Chrome 11. It is |
| 211 |
* important to keep 32-bit croppings to minimum and inline the integer |
| 212 |
* rotation. |
| 213 |
*/ |
| 214 |
sum = (A + (D ^ (B & (C ^ D))) + X[0] + 0xd76aa478) & 0xffffffff; |
| 215 |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); |
| 216 |
sum = (D + (C ^ (A & (B ^ C))) + X[1] + 0xe8c7b756) & 0xffffffff; |
| 217 |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); |
| 218 |
sum = (C + (B ^ (D & (A ^ B))) + X[2] + 0x242070db) & 0xffffffff; |
| 219 |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); |
| 220 |
sum = (B + (A ^ (C & (D ^ A))) + X[3] + 0xc1bdceee) & 0xffffffff; |
| 221 |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); |
| 222 |
sum = (A + (D ^ (B & (C ^ D))) + X[4] + 0xf57c0faf) & 0xffffffff; |
| 223 |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); |
| 224 |
sum = (D + (C ^ (A & (B ^ C))) + X[5] + 0x4787c62a) & 0xffffffff; |
| 225 |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); |
| 226 |
sum = (C + (B ^ (D & (A ^ B))) + X[6] + 0xa8304613) & 0xffffffff; |
| 227 |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); |
| 228 |
sum = (B + (A ^ (C & (D ^ A))) + X[7] + 0xfd469501) & 0xffffffff; |
| 229 |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); |
| 230 |
sum = (A + (D ^ (B & (C ^ D))) + X[8] + 0x698098d8) & 0xffffffff; |
| 231 |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); |
| 232 |
sum = (D + (C ^ (A & (B ^ C))) + X[9] + 0x8b44f7af) & 0xffffffff; |
| 233 |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); |
| 234 |
sum = (C + (B ^ (D & (A ^ B))) + X[10] + 0xffff5bb1) & 0xffffffff; |
| 235 |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); |
| 236 |
sum = (B + (A ^ (C & (D ^ A))) + X[11] + 0x895cd7be) & 0xffffffff; |
| 237 |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); |
| 238 |
sum = (A + (D ^ (B & (C ^ D))) + X[12] + 0x6b901122) & 0xffffffff; |
| 239 |
A = B + (((sum << 7) & 0xffffffff) | (sum >>> 25)); |
| 240 |
sum = (D + (C ^ (A & (B ^ C))) + X[13] + 0xfd987193) & 0xffffffff; |
| 241 |
D = A + (((sum << 12) & 0xffffffff) | (sum >>> 20)); |
| 242 |
sum = (C + (B ^ (D & (A ^ B))) + X[14] + 0xa679438e) & 0xffffffff; |
| 243 |
C = D + (((sum << 17) & 0xffffffff) | (sum >>> 15)); |
| 244 |
sum = (B + (A ^ (C & (D ^ A))) + X[15] + 0x49b40821) & 0xffffffff; |
| 245 |
B = C + (((sum << 22) & 0xffffffff) | (sum >>> 10)); |
| 246 |
sum = (A + (C ^ (D & (B ^ C))) + X[1] + 0xf61e2562) & 0xffffffff; |
| 247 |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); |
| 248 |
sum = (D + (B ^ (C & (A ^ B))) + X[6] + 0xc040b340) & 0xffffffff; |
| 249 |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); |
| 250 |
sum = (C + (A ^ (B & (D ^ A))) + X[11] + 0x265e5a51) & 0xffffffff; |
| 251 |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); |
| 252 |
sum = (B + (D ^ (A & (C ^ D))) + X[0] + 0xe9b6c7aa) & 0xffffffff; |
| 253 |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); |
| 254 |
sum = (A + (C ^ (D & (B ^ C))) + X[5] + 0xd62f105d) & 0xffffffff; |
| 255 |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); |
| 256 |
sum = (D + (B ^ (C & (A ^ B))) + X[10] + 0x02441453) & 0xffffffff; |
| 257 |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); |
| 258 |
sum = (C + (A ^ (B & (D ^ A))) + X[15] + 0xd8a1e681) & 0xffffffff; |
| 259 |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); |
| 260 |
sum = (B + (D ^ (A & (C ^ D))) + X[4] + 0xe7d3fbc8) & 0xffffffff; |
| 261 |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); |
| 262 |
sum = (A + (C ^ (D & (B ^ C))) + X[9] + 0x21e1cde6) & 0xffffffff; |
| 263 |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); |
| 264 |
sum = (D + (B ^ (C & (A ^ B))) + X[14] + 0xc33707d6) & 0xffffffff; |
| 265 |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); |
| 266 |
sum = (C + (A ^ (B & (D ^ A))) + X[3] + 0xf4d50d87) & 0xffffffff; |
| 267 |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); |
| 268 |
sum = (B + (D ^ (A & (C ^ D))) + X[8] + 0x455a14ed) & 0xffffffff; |
| 269 |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); |
| 270 |
sum = (A + (C ^ (D & (B ^ C))) + X[13] + 0xa9e3e905) & 0xffffffff; |
| 271 |
A = B + (((sum << 5) & 0xffffffff) | (sum >>> 27)); |
| 272 |
sum = (D + (B ^ (C & (A ^ B))) + X[2] + 0xfcefa3f8) & 0xffffffff; |
| 273 |
D = A + (((sum << 9) & 0xffffffff) | (sum >>> 23)); |
| 274 |
sum = (C + (A ^ (B & (D ^ A))) + X[7] + 0x676f02d9) & 0xffffffff; |
| 275 |
C = D + (((sum << 14) & 0xffffffff) | (sum >>> 18)); |
| 276 |
sum = (B + (D ^ (A & (C ^ D))) + X[12] + 0x8d2a4c8a) & 0xffffffff; |
| 277 |
B = C + (((sum << 20) & 0xffffffff) | (sum >>> 12)); |
| 278 |
sum = (A + (B ^ C ^ D) + X[5] + 0xfffa3942) & 0xffffffff; |
| 279 |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); |
| 280 |
sum = (D + (A ^ B ^ C) + X[8] + 0x8771f681) & 0xffffffff; |
| 281 |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); |
| 282 |
sum = (C + (D ^ A ^ B) + X[11] + 0x6d9d6122) & 0xffffffff; |
| 283 |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); |
| 284 |
sum = (B + (C ^ D ^ A) + X[14] + 0xfde5380c) & 0xffffffff; |
| 285 |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); |
| 286 |
sum = (A + (B ^ C ^ D) + X[1] + 0xa4beea44) & 0xffffffff; |
| 287 |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); |
| 288 |
sum = (D + (A ^ B ^ C) + X[4] + 0x4bdecfa9) & 0xffffffff; |
| 289 |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); |
| 290 |
sum = (C + (D ^ A ^ B) + X[7] + 0xf6bb4b60) & 0xffffffff; |
| 291 |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); |
| 292 |
sum = (B + (C ^ D ^ A) + X[10] + 0xbebfbc70) & 0xffffffff; |
| 293 |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); |
| 294 |
sum = (A + (B ^ C ^ D) + X[13] + 0x289b7ec6) & 0xffffffff; |
| 295 |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); |
| 296 |
sum = (D + (A ^ B ^ C) + X[0] + 0xeaa127fa) & 0xffffffff; |
| 297 |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); |
| 298 |
sum = (C + (D ^ A ^ B) + X[3] + 0xd4ef3085) & 0xffffffff; |
| 299 |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); |
| 300 |
sum = (B + (C ^ D ^ A) + X[6] + 0x04881d05) & 0xffffffff; |
| 301 |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); |
| 302 |
sum = (A + (B ^ C ^ D) + X[9] + 0xd9d4d039) & 0xffffffff; |
| 303 |
A = B + (((sum << 4) & 0xffffffff) | (sum >>> 28)); |
| 304 |
sum = (D + (A ^ B ^ C) + X[12] + 0xe6db99e5) & 0xffffffff; |
| 305 |
D = A + (((sum << 11) & 0xffffffff) | (sum >>> 21)); |
| 306 |
sum = (C + (D ^ A ^ B) + X[15] + 0x1fa27cf8) & 0xffffffff; |
| 307 |
C = D + (((sum << 16) & 0xffffffff) | (sum >>> 16)); |
| 308 |
sum = (B + (C ^ D ^ A) + X[2] + 0xc4ac5665) & 0xffffffff; |
| 309 |
B = C + (((sum << 23) & 0xffffffff) | (sum >>> 9)); |
| 310 |
sum = (A + (C ^ (B | (~D))) + X[0] + 0xf4292244) & 0xffffffff; |
| 311 |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); |
| 312 |
sum = (D + (B ^ (A | (~C))) + X[7] + 0x432aff97) & 0xffffffff; |
| 313 |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); |
| 314 |
sum = (C + (A ^ (D | (~B))) + X[14] + 0xab9423a7) & 0xffffffff; |
| 315 |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); |
| 316 |
sum = (B + (D ^ (C | (~A))) + X[5] + 0xfc93a039) & 0xffffffff; |
| 317 |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); |
| 318 |
sum = (A + (C ^ (B | (~D))) + X[12] + 0x655b59c3) & 0xffffffff; |
| 319 |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); |
| 320 |
sum = (D + (B ^ (A | (~C))) + X[3] + 0x8f0ccc92) & 0xffffffff; |
| 321 |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); |
| 322 |
sum = (C + (A ^ (D | (~B))) + X[10] + 0xffeff47d) & 0xffffffff; |
| 323 |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); |
| 324 |
sum = (B + (D ^ (C | (~A))) + X[1] + 0x85845dd1) & 0xffffffff; |
| 325 |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); |
| 326 |
sum = (A + (C ^ (B | (~D))) + X[8] + 0x6fa87e4f) & 0xffffffff; |
| 327 |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); |
| 328 |
sum = (D + (B ^ (A | (~C))) + X[15] + 0xfe2ce6e0) & 0xffffffff; |
| 329 |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); |
| 330 |
sum = (C + (A ^ (D | (~B))) + X[6] + 0xa3014314) & 0xffffffff; |
| 331 |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); |
| 332 |
sum = (B + (D ^ (C | (~A))) + X[13] + 0x4e0811a1) & 0xffffffff; |
| 333 |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); |
| 334 |
sum = (A + (C ^ (B | (~D))) + X[4] + 0xf7537e82) & 0xffffffff; |
| 335 |
A = B + (((sum << 6) & 0xffffffff) | (sum >>> 26)); |
| 336 |
sum = (D + (B ^ (A | (~C))) + X[11] + 0xbd3af235) & 0xffffffff; |
| 337 |
D = A + (((sum << 10) & 0xffffffff) | (sum >>> 22)); |
| 338 |
sum = (C + (A ^ (D | (~B))) + X[2] + 0x2ad7d2bb) & 0xffffffff; |
| 339 |
C = D + (((sum << 15) & 0xffffffff) | (sum >>> 17)); |
| 340 |
sum = (B + (D ^ (C | (~A))) + X[9] + 0xeb86d391) & 0xffffffff; |
| 341 |
B = C + (((sum << 21) & 0xffffffff) | (sum >>> 11)); |
| 342 |
|
| 343 |
this.chain_[0] = (this.chain_[0] + A) & 0xffffffff; |
| 344 |
this.chain_[1] = (this.chain_[1] + B) & 0xffffffff; |
| 345 |
this.chain_[2] = (this.chain_[2] + C) & 0xffffffff; |
| 346 |
this.chain_[3] = (this.chain_[3] + D) & 0xffffffff; |
| 347 |
}; |
| 348 |
|
| 349 |
|
| 350 |
/** @override */ |
| 351 |
goog.crypt.Md5.prototype.update = function(bytes, opt_length) { |
| 352 |
if (!goog.isDef(opt_length)) { |
| 353 |
opt_length = bytes.length; |
| 354 |
} |
| 355 |
var lengthMinusBlock = opt_length - this.blockSize; |
| 356 |
|
| 357 |
// Copy some object properties to local variables in order to save on access |
| 358 |
// time from inside the loop (~10% speedup was observed on Chrome 11). |
| 359 |
var block = this.block_; |
| 360 |
var blockLength = this.blockLength_; |
| 361 |
var i = 0; |
| 362 |
|
| 363 |
// The outer while loop should execute at most twice. |
| 364 |
while (i < opt_length) { |
| 365 |
// When we have no data in the block to top up, we can directly process the |
| 366 |
// input buffer (assuming it contains sufficient data). This gives ~30% |
| 367 |
// speedup on Chrome 14 and ~70% speedup on Firefox 6.0, but requires that |
| 368 |
// the data is provided in large chunks (or in multiples of 64 bytes). |
| 369 |
if (blockLength == 0) { |
| 370 |
while (i <= lengthMinusBlock) { |
| 371 |
this.compress_(bytes, i); |
| 372 |
i += this.blockSize; |
| 373 |
} |
| 374 |
} |
| 375 |
|
| 376 |
if (goog.isString(bytes)) { |
| 377 |
while (i < opt_length) { |
| 378 |
block[blockLength++] = bytes.charCodeAt(i++); |
| 379 |
if (blockLength == this.blockSize) { |
| 380 |
this.compress_(block); |
| 381 |
blockLength = 0; |
| 382 |
// Jump to the outer loop so we use the full-block optimization. |
| 383 |
break; |
| 384 |
} |
| 385 |
} |
| 386 |
} else { |
| 387 |
while (i < opt_length) { |
| 388 |
block[blockLength++] = bytes[i++]; |
| 389 |
if (blockLength == this.blockSize) { |
| 390 |
this.compress_(block); |
| 391 |
blockLength = 0; |
| 392 |
// Jump to the outer loop so we use the full-block optimization. |
| 393 |
break; |
| 394 |
} |
| 395 |
} |
| 396 |
} |
| 397 |
} |
| 398 |
|
| 399 |
this.blockLength_ = blockLength; |
| 400 |
this.totalLength_ += opt_length; |
| 401 |
}; |
| 402 |
|
| 403 |
|
| 404 |
/** @override */ |
| 405 |
goog.crypt.Md5.prototype.digest = function() { |
| 406 |
// This must accommodate at least 1 padding byte (0x80), 8 bytes of |
| 407 |
// total bitlength, and must end at a 64-byte boundary. |
| 408 |
var pad = new Array( |
| 409 |
(this.blockLength_ < 56 ? this.blockSize : this.blockSize * 2) - |
| 410 |
this.blockLength_); |
| 411 |
|
| 412 |
// Add padding: 0x80 0x00* |
| 413 |
pad[0] = 0x80; |
| 414 |
for (var i = 1; i < pad.length - 8; ++i) { |
| 415 |
pad[i] = 0; |
| 416 |
} |
| 417 |
// Add the total number of bits, little endian 64-bit integer. |
| 418 |
var totalBits = this.totalLength_ * 8; |
| 419 |
for (var i = pad.length - 8; i < pad.length; ++i) { |
| 420 |
pad[i] = totalBits & 0xff; |
| 421 |
totalBits /= 0x100; // Don't use bit-shifting here! |
| 422 |
} |
| 423 |
this.update(pad); |
| 424 |
|
| 425 |
var digest = new Array(16); |
| 426 |
var n = 0; |
| 427 |
for (var i = 0; i < 4; ++i) { |
| 428 |
for (var j = 0; j < 32; j += 8) { |
| 429 |
digest[n++] = (this.chain_[i] >>> j) & 0xff; |
| 430 |
} |
| 431 |
} |
| 432 |
return digest; |
| 433 |
}; |