corrade-nucleus-nucleons – Blame information for rev
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
2 | office | 1 | /* |
2 | CryptoJS v3.1.2 |
||
3 | code.google.com/p/crypto-js |
||
4 | (c) 2009-2013 by Jeff Mott. All rights reserved. |
||
5 | code.google.com/p/crypto-js/wiki/License |
||
6 | */ |
||
7 | /** |
||
8 | * CryptoJS core components. |
||
9 | */ |
||
10 | var CryptoJS = CryptoJS || (function (Math, undefined) { |
||
11 | /** |
||
12 | * CryptoJS namespace. |
||
13 | */ |
||
14 | var C = {}; |
||
15 | |||
16 | /** |
||
17 | * Library namespace. |
||
18 | */ |
||
19 | var C_lib = C.lib = {}; |
||
20 | |||
21 | /** |
||
22 | * Base object for prototypal inheritance. |
||
23 | */ |
||
24 | var Base = C_lib.Base = (function () { |
||
25 | function F() {} |
||
26 | |||
27 | return { |
||
28 | /** |
||
29 | * Creates a new object that inherits from this object. |
||
30 | * |
||
31 | * @param {Object} overrides Properties to copy into the new object. |
||
32 | * |
||
33 | * @return {Object} The new object. |
||
34 | * |
||
35 | * @static |
||
36 | * |
||
37 | * @example |
||
38 | * |
||
39 | * var MyType = CryptoJS.lib.Base.extend({ |
||
40 | * field: 'value', |
||
41 | * |
||
42 | * method: function () { |
||
43 | * } |
||
44 | * }); |
||
45 | */ |
||
46 | extend: function (overrides) { |
||
47 | // Spawn |
||
48 | F.prototype = this; |
||
49 | var subtype = new F(); |
||
50 | |||
51 | // Augment |
||
52 | if (overrides) { |
||
53 | subtype.mixIn(overrides); |
||
54 | } |
||
55 | |||
56 | // Create default initializer |
||
57 | if (!subtype.hasOwnProperty('init')) { |
||
58 | subtype.init = function () { |
||
59 | subtype.$super.init.apply(this, arguments); |
||
60 | }; |
||
61 | } |
||
62 | |||
63 | // Initializer's prototype is the subtype object |
||
64 | subtype.init.prototype = subtype; |
||
65 | |||
66 | // Reference supertype |
||
67 | subtype.$super = this; |
||
68 | |||
69 | return subtype; |
||
70 | }, |
||
71 | |||
72 | /** |
||
73 | * Extends this object and runs the init method. |
||
74 | * Arguments to create() will be passed to init(). |
||
75 | * |
||
76 | * @return {Object} The new object. |
||
77 | * |
||
78 | * @static |
||
79 | * |
||
80 | * @example |
||
81 | * |
||
82 | * var instance = MyType.create(); |
||
83 | */ |
||
84 | create: function () { |
||
85 | var instance = this.extend(); |
||
86 | instance.init.apply(instance, arguments); |
||
87 | |||
88 | return instance; |
||
89 | }, |
||
90 | |||
91 | /** |
||
92 | * Initializes a newly created object. |
||
93 | * Override this method to add some logic when your objects are created. |
||
94 | * |
||
95 | * @example |
||
96 | * |
||
97 | * var MyType = CryptoJS.lib.Base.extend({ |
||
98 | * init: function () { |
||
99 | * // ... |
||
100 | * } |
||
101 | * }); |
||
102 | */ |
||
103 | init: function () { |
||
104 | }, |
||
105 | |||
106 | /** |
||
107 | * Copies properties into this object. |
||
108 | * |
||
109 | * @param {Object} properties The properties to mix in. |
||
110 | * |
||
111 | * @example |
||
112 | * |
||
113 | * MyType.mixIn({ |
||
114 | * field: 'value' |
||
115 | * }); |
||
116 | */ |
||
117 | mixIn: function (properties) { |
||
118 | for (var propertyName in properties) { |
||
119 | if (properties.hasOwnProperty(propertyName)) { |
||
120 | this[propertyName] = properties[propertyName]; |
||
121 | } |
||
122 | } |
||
123 | |||
124 | // IE won't copy toString using the loop above |
||
125 | if (properties.hasOwnProperty('toString')) { |
||
126 | this.toString = properties.toString; |
||
127 | } |
||
128 | }, |
||
129 | |||
130 | /** |
||
131 | * Creates a copy of this object. |
||
132 | * |
||
133 | * @return {Object} The clone. |
||
134 | * |
||
135 | * @example |
||
136 | * |
||
137 | * var clone = instance.clone(); |
||
138 | */ |
||
139 | clone: function () { |
||
140 | return this.init.prototype.extend(this); |
||
141 | } |
||
142 | }; |
||
143 | }()); |
||
144 | |||
145 | /** |
||
146 | * An array of 32-bit words. |
||
147 | * |
||
148 | * @property {Array} words The array of 32-bit words. |
||
149 | * @property {number} sigBytes The number of significant bytes in this word array. |
||
150 | */ |
||
151 | var WordArray = C_lib.WordArray = Base.extend({ |
||
152 | /** |
||
153 | * Initializes a newly created word array. |
||
154 | * |
||
155 | * @param {Array} words (Optional) An array of 32-bit words. |
||
156 | * @param {number} sigBytes (Optional) The number of significant bytes in the words. |
||
157 | * |
||
158 | * @example |
||
159 | * |
||
160 | * var wordArray = CryptoJS.lib.WordArray.create(); |
||
161 | * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); |
||
162 | * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); |
||
163 | */ |
||
164 | init: function (words, sigBytes) { |
||
165 | words = this.words = words || []; |
||
166 | |||
167 | if (sigBytes != undefined) { |
||
168 | this.sigBytes = sigBytes; |
||
169 | } else { |
||
170 | this.sigBytes = words.length * 4; |
||
171 | } |
||
172 | }, |
||
173 | |||
174 | /** |
||
175 | * Converts this word array to a string. |
||
176 | * |
||
177 | * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex |
||
178 | * |
||
179 | * @return {string} The stringified word array. |
||
180 | * |
||
181 | * @example |
||
182 | * |
||
183 | * var string = wordArray + ''; |
||
184 | * var string = wordArray.toString(); |
||
185 | * var string = wordArray.toString(CryptoJS.enc.Utf8); |
||
186 | */ |
||
187 | toString: function (encoder) { |
||
188 | return (encoder || Hex).stringify(this); |
||
189 | }, |
||
190 | |||
191 | /** |
||
192 | * Concatenates a word array to this word array. |
||
193 | * |
||
194 | * @param {WordArray} wordArray The word array to append. |
||
195 | * |
||
196 | * @return {WordArray} This word array. |
||
197 | * |
||
198 | * @example |
||
199 | * |
||
200 | * wordArray1.concat(wordArray2); |
||
201 | */ |
||
202 | concat: function (wordArray) { |
||
203 | // Shortcuts |
||
204 | var thisWords = this.words; |
||
205 | var thatWords = wordArray.words; |
||
206 | var thisSigBytes = this.sigBytes; |
||
207 | var thatSigBytes = wordArray.sigBytes; |
||
208 | |||
209 | // Clamp excess bits |
||
210 | this.clamp(); |
||
211 | |||
212 | // Concat |
||
213 | if (thisSigBytes % 4) { |
||
214 | // Copy one byte at a time |
||
215 | for (var i = 0; i < thatSigBytes; i++) { |
||
216 | var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; |
||
217 | thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); |
||
218 | } |
||
219 | } else if (thatWords.length > 0xffff) { |
||
220 | // Copy one word at a time |
||
221 | for (var i = 0; i < thatSigBytes; i += 4) { |
||
222 | thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2]; |
||
223 | } |
||
224 | } else { |
||
225 | // Copy all words at once |
||
226 | thisWords.push.apply(thisWords, thatWords); |
||
227 | } |
||
228 | this.sigBytes += thatSigBytes; |
||
229 | |||
230 | // Chainable |
||
231 | return this; |
||
232 | }, |
||
233 | |||
234 | /** |
||
235 | * Removes insignificant bits. |
||
236 | * |
||
237 | * @example |
||
238 | * |
||
239 | * wordArray.clamp(); |
||
240 | */ |
||
241 | clamp: function () { |
||
242 | // Shortcuts |
||
243 | var words = this.words; |
||
244 | var sigBytes = this.sigBytes; |
||
245 | |||
246 | // Clamp |
||
247 | words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); |
||
248 | words.length = Math.ceil(sigBytes / 4); |
||
249 | }, |
||
250 | |||
251 | /** |
||
252 | * Creates a copy of this word array. |
||
253 | * |
||
254 | * @return {WordArray} The clone. |
||
255 | * |
||
256 | * @example |
||
257 | * |
||
258 | * var clone = wordArray.clone(); |
||
259 | */ |
||
260 | clone: function () { |
||
261 | var clone = Base.clone.call(this); |
||
262 | clone.words = this.words.slice(0); |
||
263 | |||
264 | return clone; |
||
265 | }, |
||
266 | |||
267 | /** |
||
268 | * Creates a word array filled with random bytes. |
||
269 | * |
||
270 | * @param {number} nBytes The number of random bytes to generate. |
||
271 | * |
||
272 | * @return {WordArray} The random word array. |
||
273 | * |
||
274 | * @static |
||
275 | * |
||
276 | * @example |
||
277 | * |
||
278 | * var wordArray = CryptoJS.lib.WordArray.random(16); |
||
279 | */ |
||
280 | random: function (nBytes) { |
||
281 | var words = []; |
||
282 | for (var i = 0; i < nBytes; i += 4) {> |
||
283 | < nBytes; i += 4) { words.push((Math.random() * 0x100000000) | 0);> |
||
284 | < nBytes; i += 4) { }> |
||
285 | |||
286 | < nBytes; i += 4) { return new WordArray.init(words, nBytes);> |
||
287 | < nBytes; i += 4) { }> |
||
288 | < nBytes; i += 4) { });> |
||
289 | |||
290 | < nBytes; i += 4) { /**> |
||
291 | < nBytes; i += 4) { * Encoder namespace.> |
||
292 | < nBytes; i += 4) { */> |
||
293 | < nBytes; i += 4) { var C_enc = C.enc = {};> |
||
294 | |||
295 | < nBytes; i += 4) { /**> |
||
296 | < nBytes; i += 4) { * Hex encoding strategy.> |
||
297 | < nBytes; i += 4) { */> |
||
298 | < nBytes; i += 4) { var Hex = C_enc.Hex = {> |
||
299 | < nBytes; i += 4) { /**> |
||
300 | < nBytes; i += 4) { * Converts a word array to a hex string.> |
||
301 | < nBytes; i += 4) { *> |
||
302 | < nBytes; i += 4) { * @param {WordArray} wordArray The word array.> |
||
303 | < nBytes; i += 4) { *> |
||
304 | < nBytes; i += 4) { * @return {string} The hex string.> |
||
305 | < nBytes; i += 4) { *> |
||
306 | < nBytes; i += 4) { * @static> |
||
307 | < nBytes; i += 4) { *> |
||
308 | < nBytes; i += 4) { * @example> |
||
309 | < nBytes; i += 4) { *> |
||
310 | < nBytes; i += 4) { * var hexString = CryptoJS.enc.Hex.stringify(wordArray);> |
||
311 | < nBytes; i += 4) { */> |
||
312 | < nBytes; i += 4) { stringify: function (wordArray) {> |
||
313 | < nBytes; i += 4) { // Shortcuts> |
||
314 | < nBytes; i += 4) { var words = wordArray.words;> |
||
315 | < nBytes; i += 4) { var sigBytes = wordArray.sigBytes;> |
||
316 | |||
317 | < nBytes; i += 4) { // Convert> |
||
318 | < nBytes; i += 4) { var hexChars = [];> |
||
319 | < nBytes; i += 4) { for (var i = 0; i < sigBytes; i++) {>> |
||
320 | < nBytes; i += 4) {< sigBytes; i++) { var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;>> |
||
321 | < nBytes; i += 4) {< sigBytes; i++) { hexChars.push((bite >>> 4).toString(16));>> |
||
322 | < nBytes; i += 4) {< sigBytes; i++) { hexChars.push((bite & 0x0f).toString(16));>> |
||
323 | < nBytes; i += 4) {< sigBytes; i++) { }>> |
||
324 | |||
325 | < nBytes; i += 4) {< sigBytes; i++) { return hexChars.join('');>> |
||
326 | < nBytes; i += 4) {< sigBytes; i++) { },>> |
||
327 | |||
328 | < nBytes; i += 4) {< sigBytes; i++) { /**>> |
||
329 | < nBytes; i += 4) {< sigBytes; i++) { * Converts a hex string to a word array.>> |
||
330 | < nBytes; i += 4) {< sigBytes; i++) { *>> |
||
331 | < nBytes; i += 4) {< sigBytes; i++) { * @param {string} hexStr The hex string.>> |
||
332 | < nBytes; i += 4) {< sigBytes; i++) { *>> |
||
333 | < nBytes; i += 4) {< sigBytes; i++) { * @return {WordArray} The word array.>> |
||
334 | < nBytes; i += 4) {< sigBytes; i++) { *>> |
||
335 | < nBytes; i += 4) {< sigBytes; i++) { * @static>> |
||
336 | < nBytes; i += 4) {< sigBytes; i++) { *>> |
||
337 | < nBytes; i += 4) {< sigBytes; i++) { * @example>> |
||
338 | < nBytes; i += 4) {< sigBytes; i++) { *>> |
||
339 | < nBytes; i += 4) {< sigBytes; i++) { * var wordArray = CryptoJS.enc.Hex.parse(hexString);>> |
||
340 | < nBytes; i += 4) {< sigBytes; i++) { */>> |
||
341 | < nBytes; i += 4) {< sigBytes; i++) { parse: function (hexStr) {>> |
||
342 | < nBytes; i += 4) {< sigBytes; i++) { // Shortcut>> |
||
343 | < nBytes; i += 4) {< sigBytes; i++) { var hexStrLength = hexStr.length;>> |
||
344 | |||
345 | < nBytes; i += 4) {< sigBytes; i++) { // Convert>> |
||
346 | < nBytes; i += 4) {< sigBytes; i++) { var words = [];>> |
||
347 | < nBytes; i += 4) {< sigBytes; i++) { for (var i = 0; i < hexStrLength; i += 2) {>>> |
||
348 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) { words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);><>>>> |
||
349 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
350 | |||
351 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return new WordArray.init(words, hexStrLength / 2);><>>>> |
||
352 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
353 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };><>>>> |
||
354 | |||
355 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
356 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Latin1 encoding strategy.><>>>> |
||
357 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
358 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var Latin1 = C_enc.Latin1 = {><>>>> |
||
359 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
360 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a word array to a Latin1 string.><>>>> |
||
361 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
362 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray} wordArray The word array.><>>>> |
||
363 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
364 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {string} The Latin1 string.><>>>> |
||
365 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
366 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static><>>>> |
||
367 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
368 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
369 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
370 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);><>>>> |
||
371 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
372 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); stringify: function (wordArray) {><>>>> |
||
373 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcuts><>>>> |
||
374 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var words = wordArray.words;><>>>> |
||
375 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var sigBytes = wordArray.sigBytes;><>>>> |
||
376 | |||
377 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert><>>>> |
||
378 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var latin1Chars = [];><>>>> |
||
379 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var i = 0; i < sigBytes; i++) {><>>>> |
||
380 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;><>>>> |
||
381 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); latin1Chars.push(String.fromCharCode(bite));><>>>> |
||
382 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
383 | |||
384 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return latin1Chars.join('');><>>>> |
||
385 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },><>>>> |
||
386 | |||
387 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
388 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a Latin1 string to a word array.><>>>> |
||
389 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
390 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {string} latin1Str The Latin1 string.><>>>> |
||
391 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
392 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The word array.><>>>> |
||
393 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
394 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static><>>>> |
||
395 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
396 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
397 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
398 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);><>>>> |
||
399 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
400 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); parse: function (latin1Str) {><>>>> |
||
401 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcut><>>>> |
||
402 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var latin1StrLength = latin1Str.length;><>>>> |
||
403 | |||
404 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert><>>>> |
||
405 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var words = [];><>>>> |
||
406 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var i = 0; i < latin1StrLength; i++) {><>>>> |
||
407 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);><>>>> |
||
408 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
409 | |||
410 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return new WordArray.init(words, latin1StrLength);><>>>> |
||
411 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
412 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };><>>>> |
||
413 | |||
414 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
415 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * UTF-8 encoding strategy.><>>>> |
||
416 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
417 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var Utf8 = C_enc.Utf8 = {><>>>> |
||
418 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
419 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a word array to a UTF-8 string.><>>>> |
||
420 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
421 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray} wordArray The word array.><>>>> |
||
422 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
423 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {string} The UTF-8 string.><>>>> |
||
424 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
425 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static><>>>> |
||
426 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
427 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
428 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
429 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);><>>>> |
||
430 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
431 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); stringify: function (wordArray) {><>>>> |
||
432 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); try {><>>>> |
||
433 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return decodeURIComponent(escape(Latin1.stringify(wordArray)));><>>>> |
||
434 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); } catch (e) {><>>>> |
||
435 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); throw new Error('Malformed UTF-8 data');><>>>> |
||
436 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
437 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },><>>>> |
||
438 | |||
439 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
440 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Converts a UTF-8 string to a word array.><>>>> |
||
441 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
442 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {string} utf8Str The UTF-8 string.><>>>> |
||
443 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
444 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The word array.><>>>> |
||
445 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
446 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @static><>>>> |
||
447 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
448 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
449 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
450 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);><>>>> |
||
451 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
452 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); parse: function (utf8Str) {><>>>> |
||
453 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); return Latin1.parse(unescape(encodeURIComponent(utf8Str)));><>>>> |
||
454 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
455 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); };><>>>> |
||
456 | |||
457 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
458 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Abstract buffered block algorithm template.><>>>> |
||
459 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
460 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * The property blockSize must be implemented in a concrete subtype.><>>>> |
||
461 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
462 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0><>>>> |
||
463 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
464 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({><>>>> |
||
465 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
466 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Resets this block algorithm's data buffer to its initial state.><>>>> |
||
467 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
468 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
469 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
470 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm.reset();><>>>> |
||
471 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
472 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); reset: function () {><>>>> |
||
473 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Initial values><>>>> |
||
474 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._data = new WordArray.init();><>>>> |
||
475 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._nDataBytes = 0;><>>>> |
||
476 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },><>>>> |
||
477 | |||
478 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
479 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Adds new data to this block algorithm's buffer.><>>>> |
||
480 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
481 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.><>>>> |
||
482 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
483 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
484 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
485 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm._append('data');><>>>> |
||
486 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * bufferedBlockAlgorithm._append(wordArray);><>>>> |
||
487 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
488 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); _append: function (data) {><>>>> |
||
489 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Convert string to WordArray, else assume WordArray already><>>>> |
||
490 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (typeof data == 'string') {><>>>> |
||
491 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); data = Utf8.parse(data);><>>>> |
||
492 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
493 | |||
494 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Append><>>>> |
||
495 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._data.concat(data);><>>>> |
||
496 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); this._nDataBytes += data.sigBytes;><>>>> |
||
497 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); },><>>>> |
||
498 | |||
499 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); /**><>>>> |
||
500 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * Processes available data blocks.><>>>> |
||
501 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
502 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.><>>>> |
||
503 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
504 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.><>>>> |
||
505 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
506 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @return {WordArray} The processed data.><>>>> |
||
507 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
508 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * @example><>>>> |
||
509 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); *><>>>> |
||
510 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var processedData = bufferedBlockAlgorithm._process();><>>>> |
||
511 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); * var processedData = bufferedBlockAlgorithm._process(!!'flush');><>>>> |
||
512 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); */><>>>> |
||
513 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); _process: function (doFlush) {><>>>> |
||
514 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Shortcuts><>>>> |
||
515 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var data = this._data;><>>>> |
||
516 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var dataWords = data.words;><>>>> |
||
517 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var dataSigBytes = data.sigBytes;><>>>> |
||
518 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var blockSize = this.blockSize;><>>>> |
||
519 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var blockSizeBytes = blockSize * 4;><>>>> |
||
520 | |||
521 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count blocks ready><>>>> |
||
522 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nBlocksReady = dataSigBytes / blockSizeBytes;><>>>> |
||
523 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (doFlush) {><>>>> |
||
524 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Round up to include partial blocks><>>>> |
||
525 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); nBlocksReady = Math.ceil(nBlocksReady);><>>>> |
||
526 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); } else {><>>>> |
||
527 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Round down to include only full blocks,><>>>> |
||
528 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // less the number of blocks that must remain in the buffer><>>>> |
||
529 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);><>>>> |
||
530 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); }><>>>> |
||
531 | |||
532 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count words ready><>>>> |
||
533 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nWordsReady = nBlocksReady * blockSize;><>>>> |
||
534 | |||
535 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Count bytes ready><>>>> |
||
536 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);><>>>> |
||
537 | |||
538 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); // Process blocks><>>>> |
||
539 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); if (nWordsReady) {><>>>> |
||
540 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4); for (var offset = 0; offset < nWordsReady; offset += blockSize) {>><>>>> |
||
541 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-algorithm logic>><>>>> |
||
542 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._doProcessBlock(dataWords, offset);>><>>>> |
||
543 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }>><>>>> |
||
544 | |||
545 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Remove processed words>><>>>> |
||
546 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var processedWords = dataWords.splice(0, nWordsReady);>><>>>> |
||
547 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { data.sigBytes -= nBytesReady;>><>>>> |
||
548 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }>><>>>> |
||
549 | |||
550 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Return processed words>><>>>> |
||
551 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new WordArray.init(processedWords, nBytesReady);>><>>>> |
||
552 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
553 | |||
554 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
555 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a copy of this object.>><>>>> |
||
556 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
557 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Object} The clone.>><>>>> |
||
558 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
559 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
560 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
561 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var clone = bufferedBlockAlgorithm.clone();>><>>>> |
||
562 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
563 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { clone: function () {>><>>>> |
||
564 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var clone = Base.clone.call(this);>><>>>> |
||
565 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { clone._data = this._data.clone();>><>>>> |
||
566 | |||
567 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return clone;>><>>>> |
||
568 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
569 | |||
570 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _minBufferSize: 0>><>>>> |
||
571 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { });>><>>>> |
||
572 | |||
573 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
574 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Abstract hasher template.>><>>>> |
||
575 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
576 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)>><>>>> |
||
577 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
578 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({>><>>>> |
||
579 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
580 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Configuration options.>><>>>> |
||
581 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
582 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { cfg: Base.extend(),>><>>>> |
||
583 | |||
584 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
585 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Initializes a newly created hasher.>><>>>> |
||
586 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
587 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Object} cfg (Optional) The configuration options to use for this hash computation.>><>>>> |
||
588 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
589 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
590 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
591 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hasher = CryptoJS.algo.SHA256.create();>><>>>> |
||
592 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
593 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { init: function (cfg) {>><>>>> |
||
594 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Apply config defaults>><>>>> |
||
595 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this.cfg = this.cfg.extend(cfg);>><>>>> |
||
596 | |||
597 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Set initial values>><>>>> |
||
598 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this.reset();>><>>>> |
||
599 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
600 | |||
601 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
602 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Resets this hasher to its initial state.>><>>>> |
||
603 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
604 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
605 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
606 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.reset();>><>>>> |
||
607 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
608 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { reset: function () {>><>>>> |
||
609 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Reset data buffer>><>>>> |
||
610 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { BufferedBlockAlgorithm.reset.call(this);>><>>>> |
||
611 | |||
612 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-hasher logic>><>>>> |
||
613 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._doReset();>><>>>> |
||
614 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
615 | |||
616 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
617 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Updates this hasher with a message.>><>>>> |
||
618 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
619 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {WordArray|string} messageUpdate The message to append.>><>>>> |
||
620 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
621 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Hasher} This hasher.>><>>>> |
||
622 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
623 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
624 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
625 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.update('message');>><>>>> |
||
626 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * hasher.update(wordArray);>><>>>> |
||
627 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
628 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { update: function (messageUpdate) {>><>>>> |
||
629 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Append>><>>>> |
||
630 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._append(messageUpdate);>><>>>> |
||
631 | |||
632 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Update the hash>><>>>> |
||
633 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._process();>><>>>> |
||
634 | |||
635 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Chainable>><>>>> |
||
636 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return this;>><>>>> |
||
637 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
638 | |||
639 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
640 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Finalizes the hash computation.>><>>>> |
||
641 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Note that the finalize operation is effectively a destructive, read-once operation.>><>>>> |
||
642 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
643 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {WordArray|string} messageUpdate (Optional) A final message update.>><>>>> |
||
644 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
645 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {WordArray} The hash.>><>>>> |
||
646 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
647 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
648 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
649 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize();>><>>>> |
||
650 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize('message');>><>>>> |
||
651 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var hash = hasher.finalize(wordArray);>><>>>> |
||
652 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
653 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { finalize: function (messageUpdate) {>><>>>> |
||
654 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Final message update>><>>>> |
||
655 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { if (messageUpdate) {>><>>>> |
||
656 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { this._append(messageUpdate);>><>>>> |
||
657 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }>><>>>> |
||
658 | |||
659 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { // Perform concrete-hasher logic>><>>>> |
||
660 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var hash = this._doFinalize();>><>>>> |
||
661 | |||
662 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return hash;>><>>>> |
||
663 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
664 | |||
665 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { blockSize: 512/32,>><>>>> |
||
666 | |||
667 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
668 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a shortcut function to a hasher's object interface.>><>>>> |
||
669 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
670 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Hasher} hasher The hasher to create a helper for.>><>>>> |
||
671 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
672 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Function} The shortcut function.>><>>>> |
||
673 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
674 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @static>><>>>> |
||
675 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
676 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
677 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
678 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);>><>>>> |
||
679 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
680 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _createHelper: function (hasher) {>><>>>> |
||
681 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return function (message, cfg) {>><>>>> |
||
682 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new hasher.init(cfg).finalize(message);>><>>>> |
||
683 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { };>><>>>> |
||
684 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { },>><>>>> |
||
685 | |||
686 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
687 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Creates a shortcut function to the HMAC's object interface.>><>>>> |
||
688 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
689 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @param {Hasher} hasher The hasher to use in this HMAC helper.>><>>>> |
||
690 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
691 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @return {Function} The shortcut function.>><>>>> |
||
692 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
693 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @static>><>>>> |
||
694 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
695 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * @example>><>>>> |
||
696 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { *>><>>>> |
||
697 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);>><>>>> |
||
698 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
699 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { _createHmacHelper: function (hasher) {>><>>>> |
||
700 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return function (message, key) {>><>>>> |
||
701 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return new C_algo.HMAC.init(hasher, key).finalize(message);>><>>>> |
||
702 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { };>><>>>> |
||
703 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { }>><>>>> |
||
704 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { });>><>>>> |
||
705 | |||
706 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { /**>><>>>> |
||
707 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { * Algorithm namespace.>><>>>> |
||
708 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { */>><>>>> |
||
709 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { var C_algo = C.algo = {};>><>>>> |
||
710 | |||
711 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) { return C;>><>>>> |
||
712 | < nBytes; i += 4) {< sigBytes; i++) {< hexStrLength; i += 2) {<< (24 - (i % 8) * 4);< (24 - (i % 8) * 4);< nWordsReady; offset += blockSize) {}(Math));>><>>>> |