Wikipedysta:Persino/SHA1.js

// The following is useful for calculating 
// SHA1 hashes of files - client side, before uploading

/*
	Derivative work. The following changes were made:
		Use Int32Array (a so-called typed array) instead of slow JS-Array where each
		element was only weakly typed and therefore wasn't stored in just one block
		of memory.
		When reporting Errors, please include whether you are using the 32 bit version
		or the 64 bit version of a browser and your processor architecture.
*/

/*
	CryptoJS v3.1.2
	code.google.com/p/crypto-js
	(c) 2009-2013 by Jeff Mott. All rights reserved.
	code.google.com/p/crypto-js/wiki/License


	Copyright (c) 2009-2013 Jeff Mott

	Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

	The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	*/

/*jshint bitwise:false, worker:true*/
/*global escape:false, unescape:false*/
(function (w) {

	/**
	 * CryptoJS core components.
	 */
	w.CryptoJS = w.CryptoJS || (function (Math, undefined) {
		'use strict';

		var littleEndian = (function () {
			var buffer = new ArrayBuffer(2);
			new DataView(buffer).setInt16(0, 256, true);
			return new Int16Array(buffer)[0] === 256;
		})();
		
		var isOfType = function(v, t) {
				return Object.prototype.toString.call( v ) === '[object ' + t + ']';
			},
			isInt32Array = function(a) {
				return Object.prototype.toString.call( a ) === '[object Int32Array]';
			};

		/**
		 * CryptoJS namespace.
		 */
		var C = {};

		/**
		 * Library namespace.
		 */
		var C_lib = C.lib = {};

		/**
		 * Base object for prototypal inheritance.
		 */
		var Base = C_lib.Base = (function () {
			function F() {}

			return {
				/**
				 * Creates a new object that inherits from this object.
				 *
				 * @param {Object} overrides Properties to copy into the new object.
				 *
				 * @return {Object} The new object.
				 *
				 * @static
				 *
				 * @example
				 *
				 *     var MyType = CryptoJS.lib.Base.extend({
				 *         field: 'value',
				 *
				 *         method: function () {
				 *         }
				 *     });
				 */
				extend: function (overrides) {
					// Spawn
					F.prototype = this;
					var subtype = new F();

					// Augment
					if (overrides) {
						subtype.mixIn(overrides);
					}

					// Create default initializer
					if (!subtype.hasOwnProperty('init')) {
						subtype.init = function () {
							subtype.$super.init.apply(this, arguments);
						};
					}

					// Initializer's prototype is the subtype object
					subtype.init.prototype = subtype;

					// Reference supertype
					subtype.$super = this;

					return subtype;
				},

				/**
				 * Extends this object and runs the init method.
				 * Arguments to create() will be passed to init().
				 *
				 * @return {Object} The new object.
				 *
				 * @static
				 *
				 * @example
				 *
				 *     var instance = MyType.create();
				 */
				create: function () {
					var instance = this.extend();
					instance.init.apply(instance, arguments);

					return instance;
				},

				/**
				 * Initializes a newly created object.
				 * Override this method to add some logic when your objects are created.
				 *
				 * @example
				 *
				 *     var MyType = CryptoJS.lib.Base.extend({
				 *         init: function () {
				 *             // ...
				 *         }
				 *     });
				 */
				init: function () {},

				/**
				 * Copies properties into this object.
				 *
				 * @param {Object} properties The properties to mix in.
				 *
				 * @example
				 *
				 *     MyType.mixIn({
				 *         field: 'value'
				 *     });
				 */
				mixIn: function (properties) {
					for (var propertyName in properties) {
						if (properties.hasOwnProperty(propertyName)) {
							this[propertyName] = properties[propertyName];
						}
					}

					// IE won't copy toString using the loop above
					if (properties.hasOwnProperty('toString')) {
						this.toString = properties.toString;
					}
				},

				/**
				 * Creates a copy of this object.
				 *
				 * @return {Object} The clone.
				 *
				 * @example
				 *
				 *     var clone = instance.clone();
				 */
				clone: function () {
					return this.init.prototype.extend(this);
				}
			};
		}());

		/**
		 * An array of 32-bit words.
		 *
		 * @property {Array} words The array of 32-bit words.
		 * @property {number} sigBytes The number of significant bytes in this word array.
		 */
		var WordArray = C_lib.WordArray = Base.extend({
			/**
			 * Initializes a newly created word array.
			 *
			 * @param {Int32Array|Array} words (Optional) An array of 32-bit words.
			 * @param {number} sigBytes (Optional) The number of significant bytes in the words.
			 *
			 * @example
			 *
			 *     var wordArray = CryptoJS.lib.WordArray.create();
			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
			 *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
			 */
			init: function (words, sigBytes) {
				if (!words) sigBytes = 0;

				words = this.words = isInt32Array(words) ? words : new Int32Array(words || 262144); // 1024 * 256 * 32/8 =  = 1MiB

				if (sigBytes !== undefined) {
					this.sigBytes = sigBytes;
				} else {
					this.sigBytes = words.length * 4;
				}
			},

			/**
			 * Converts this word array to a string.
			 *
			 * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
			 *
			 * @return {string} The stringified word array.
			 *
			 * @example
			 *
			 *     var string = wordArray + '';
			 *     var string = wordArray.toString();
			 *     var string = wordArray.toString(CryptoJS.enc.Utf8);
			 */
			toString: function (encoder) {
				return (encoder || Hex).stringify(this);
			},

			/**
			 * Concatenates a word array to this word array.
			 *
			 * @param {WordArray} wordArray The word array to append.
			 *
			 * @return {WordArray} This word array.
			 *
			 * @example
			 *
			 *     wordArray1.concat(wordArray2);
			 */
			concat: function (wordArray) {
				// Shortcuts for faster access
				var thisWords = this.words,
					thatWords = wordArray.words,
					thisSigBytes = this.sigBytes,
					thatSigBytes = wordArray.sigBytes,
					thisSigElems = Math.ceil(thisSigBytes / 4),
					thatSigElems = Math.ceil(thatSigBytes / 4),
					// Calculate required memory
					totalSigBytes = thisSigBytes + thatSigBytes,
					totalSigElems = Math.ceil(totalSigBytes / 4);

				// Clamp excess bits
				this.clamp();

				// Allocate sufficient (and a bit more) memory
				// The "bit more" to avoid frequent allocations
				if (thisWords.length < totalSigElems) {
					this.allocFactor = (this.allocFactor || 0.5) * 2;
					var tmp = new Int32Array(totalSigElems * this.allocFactor);
					tmp.set(thisWords);
					this.words = thisWords = tmp;
				}

				// If we are in luck we can just use a native function
				// to copy the values from "wordArray" to "this" over quickly
				if (thisSigBytes % 4) {
					throw new Error(
						"There is a problem with the current implementation where the ArrayBuffer is not altered in the way wanted. Thus, this operation will likely result in a wrong hash."
					);

					// No luck; we've to create a view and copy byte by byte
					var thisDv = new DataView(thisWords.buffer),
						thatDv = new DataView(thatWords.buffer);

					var i, x;

					// There is some confusing stuff about endianness:
					// Endianness aka "byte order" sais something about the direction in which the
					// bytes are arranged in multi-byte-types: Little E. -> Insignificant first
					// Big E. -> Most significant fist; depends on processor architecture but
					// some (not all?) file formats also have specs how to write them?

					// I can imagine that this is very sloooow ... especially on little-endian sytems
					// so simply avoid non-word-aligned data
					if (littleEndian) {
						for (i = thisSigBytes, x = 0; i < totalSigBytes; i++, x++) {
							// We have to read the bytes in a different order: 3,2,1,0,7,6,5,4,11,...
							// | WORD 0     | WORD 1     |
							// | b3 b2 b1 b0| b7 b6 b5 b4|
							// base is the first byte of a word (e.g. b3 or b7)
							var baseX = x + (3 - x % 4),
								baseI = i + (3 - i % 4),
								targetOffset = (baseI * 2) - i - 3,
								sourceOffset = (baseX * 2) - x - 3;

							thisDv.setUint8(targetOffset, thatDv.getUint8(sourceOffset)); // <--- This does not change the ArrayBuffer for reasons I do not know.
							// You can test this using:
							//
							// var sha1 = CryptoJS.algo.SHA1.create();
							// sha1.update("Hall");
							// sha1.update("oworl").update("d!");
							// console.log(sha1.finalize().toString(CryptoJS.enc.Hex));
						}
					} else {
						for (i = thisSigBytes, x = 0; i < totalSigBytes; i++, x++) {
							thisDv.setUint8(i, thatDv.getUint8(x));
						}
					}
				} else {
					// Does "that" contain a rat tail?
					if (thatWords.length !== thatSigElems) {
						// Remove the rat tail first
						thatWords = thatWords.subarray(0, thatSigElems);
					}
					thisWords.set(thatWords, thisSigElems);
				}

				this.sigBytes += thatSigBytes;

				// Chainable
				return this;
			},

			/**
			 * Removes insignificant bits.
			 *
			 * @example
			 *
			 *     wordArray.clamp();
			 */
			clamp: function () {
				// Shortcuts
				var words = this.words;
				var sigBytes = this.sigBytes;

				// Clamp
				words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
				// We've allocated more memory so removing it would be counter-productive
				// words.length = Math.ceil(sigBytes / 4);
			},

			/**
			 * Creates a copy of this word array.
			 *
			 * @return {WordArray} The clone.
			 *
			 * @example
			 *
			 *     var clone = wordArray.clone();
			 */
			clone: function () {
				var clone = Base.clone.call(this);
				clone.words = new Int32Array(clone.words);

				return clone;
			},

			/**
			 * Creates a word array filled with random bytes.
			 *
			 * @param {number} nBytes The number of random bytes to generate.
			 *
			 * @return {WordArray} The random word array.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var wordArray = CryptoJS.lib.WordArray.random(16);
			 */
			random: function (nBytes) {
				var words = [];
				for (var i = 0; i < nBytes; i += 4) {
					words.push((Math.random() * 0x100000000) | 0);
				}

				return new WordArray.init(words, nBytes);
			}
		});

		/**
		 * Encoder namespace.
		 */
		var C_enc = C.enc = {};

		/**
		 * Hex encoding strategy.
		 */
		var Hex = C_enc.Hex = {
			/**
			 * Converts a word array to a hex string.
			 *
			 * @param {WordArray} wordArray The word array.
			 *
			 * @return {string} The hex string.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
			 */
			stringify: function (wordArray) {
				// Shortcuts
				var words = wordArray.words;
				var sigBytes = wordArray.sigBytes;

				// Convert
				var hexChars = [];
				for (var i = 0; i < sigBytes; i++) {
					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
					hexChars.push((bite >>> 4).toString(16));
					hexChars.push((bite & 0x0f).toString(16));
				}

				return hexChars.join('');
			},

			/**
			 * Converts a hex string to a word array.
			 *
			 * @param {string} hexStr The hex string.
			 *
			 * @return {WordArray} The word array.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
			 */
			parse: function (hexStr) {
				// Shortcut
				var hexStrLength = hexStr.length;

				// Convert
				var words = [];
				for (var i = 0; i < hexStrLength; i += 2) {
					words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
				}

				return new WordArray.init(words, hexStrLength / 2);
			}
		};

		/**
		 * Latin1 encoding strategy.
		 */
		var Latin1 = C_enc.Latin1 = {
			/**
			 * Converts a word array to a Latin1 string.
			 *
			 * @param {WordArray} wordArray The word array.
			 *
			 * @return {string} The Latin1 string.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
			 */
			stringify: function (wordArray) {
				// Shortcuts
				var words = wordArray.words;
				var sigBytes = wordArray.sigBytes;

				// Convert
				var latin1Chars = [];
				for (var i = 0; i < sigBytes; i++) {
					var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
					latin1Chars.push(String.fromCharCode(bite));
				}

				return latin1Chars.join('');
			},

			/**
			 * Converts a Latin1 string to a word array.
			 *
			 * @param {string} latin1Str The Latin1 string.
			 *
			 * @return {WordArray} The word array.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
			 */
			parse: function (latin1Str) {
				// Shortcut
				var latin1StrLength = latin1Str.length;

				// Convert
				var words = [];
				for (var i = 0; i < latin1StrLength; i++) {
					words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
				}

				return new WordArray.init(words, latin1StrLength);
			}
		};

		/**
		 * UTF-8 encoding strategy.
		 */
		var Utf8 = C_enc.Utf8 = {
			/**
			 * Converts a word array to a UTF-8 string.
			 *
			 * @param {WordArray} wordArray The word array.
			 *
			 * @return {string} The UTF-8 string.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
			 */
			stringify: function (wordArray) {
				try {
					return decodeURIComponent(escape(Latin1.stringify(wordArray)));
				} catch (e) {
					throw new Error('Malformed UTF-8 data');
				}
			},

			/**
			 * Converts a UTF-8 string to a word array.
			 *
			 * @param {string} utf8Str The UTF-8 string.
			 *
			 * @return {WordArray} The word array.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
			 */
			parse: function (utf8Str) {
				return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
			}
		};

		/**
		 * Abstract buffered block algorithm template.
		 *
		 * The property blockSize must be implemented in a concrete subtype.
		 *
		 * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
		 */
		var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
			/**
			 * Resets this block algorithm's data buffer to its initial state.
			 *
			 * @example
			 *
			 *     bufferedBlockAlgorithm.reset();
			 */
			reset: function () {
				// Initial values
				this._data = new WordArray.init();
				this._nDataBytes = 0;
			},

			/**
			 * Adds new data to this block algorithm's buffer.
			 *
			 * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
			 *
			 * @example
			 *
			 *     bufferedBlockAlgorithm._append('data');
			 *     bufferedBlockAlgorithm._append(wordArray);
			 */
			_append: function (data, sigBytes) {
				// Convert string to WordArray, else assume WordArray already
				if (typeof data === 'string') {
					data = Utf8.parse(data);
				} else if (isInt32Array(data) || data.length) {
					data = new WordArray.init(data, sigBytes);
				}

				// Append
				this._data.concat(data);
				this._nDataBytes += data.sigBytes;
			},

			/**
			 * Processes available data blocks.
			 *
			 * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
			 *
			 * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
			 *
			 * @return {WordArray} The processed data.
			 *
			 * @example
			 *
			 *     var processedData = bufferedBlockAlgorithm._process();
			 *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
			 */
			_process: function (doFlush) {
				// Shortcuts
				var data = this._data;
				var dataWords = data.words;
				var dataSigBytes = data.sigBytes;
				var blockSize = this.blockSize;
				var blockSizeBytes = blockSize * 4;

				// Count blocks ready
				var nBlocksReady = dataSigBytes / blockSizeBytes;
				if (doFlush) {
					// Round up to include partial blocks
					nBlocksReady = Math.ceil(nBlocksReady);
				} else {
					// Round down to include only full blocks,
					// less the number of blocks that must remain in the buffer
					nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
				}

				// Count words ready
				var nWordsReady = nBlocksReady * blockSize;

				// Count bytes ready
				var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);

				// Process blocks
				var processedWords;

				if (nWordsReady) {
					for (var offset = 0; offset < nWordsReady; offset += blockSize) {
						// Perform concrete-algorithm logic
						this._doProcessBlock(dataWords, offset);
					}

					// Remove processed words
					processedWords = dataWords.subarray(0, nWordsReady);
					dataWords = data.words = dataWords.subarray(nWordsReady);
					data.sigBytes -= nBytesReady;
				}

				// Return processed words
				return new WordArray.init(processedWords, nBytesReady);
			},

			/**
			 * Creates a copy of this object.
			 *
			 * @return {Object} The clone.
			 *
			 * @example
			 *
			 *     var clone = bufferedBlockAlgorithm.clone();
			 */
			clone: function () {
				var clone = Base.clone.call(this);
				clone._data = this._data.clone();

				return clone;
			},

			_minBufferSize: 0
		});

		/**
		 * Abstract hasher template.
		 *
		 * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
		 */
		var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
			/**
			 * Configuration options.
			 */
			cfg: Base.extend(),

			/**
			 * Initializes a newly created hasher.
			 *
			 * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
			 *
			 * @example
			 *
			 *     var hasher = CryptoJS.algo.SHA256.create();
			 */
			init: function (cfg) {
				// Apply config defaults
				this.cfg = this.cfg.extend(cfg);

				// Set initial values
				this.reset();
			},

			/**
			 * Resets this hasher to its initial state.
			 *
			 * @example
			 *
			 *     hasher.reset();
			 */
			reset: function () {
				// Reset data buffer
				BufferedBlockAlgorithm.reset.call(this);

				// Perform concrete-hasher logic
				this._doReset();
			},

			/**
			 * Updates this hasher with a message.
			 *
			 * @param {WordArray|string} messageUpdate The message to append.
			 *
			 * @return {Hasher} This hasher.
			 *
			 * @example
			 *
			 *     hasher.update('message');
			 *     hasher.update(wordArray);
			 */
			update: function (messageUpdate, sigBytes) {
				// Append
				this._append(messageUpdate, sigBytes);

				// Update the hash
				this._process();

				// Chainable
				return this;
			},

			/**
			 * Finalizes the hash computation.
			 * Note that the finalize operation is effectively a destructive, read-once operation.
			 *
			 * @param {WordArray|string} messageUpdate (Optional) A final message update.
			 *
			 * @return {WordArray} The hash.
			 *
			 * @example
			 *
			 *     var hash = hasher.finalize();
			 *     var hash = hasher.finalize('message');
			 *     var hash = hasher.finalize(wordArray);
			 */
			finalize: function (messageUpdate, sigBytes) {
				// Final message update
				if (messageUpdate) {
					this._append(messageUpdate, sigBytes);
				}

				// Perform concrete-hasher logic
				var hash = this._doFinalize();

				return hash;
			},

			blockSize: 512 / 32,

			/**
			 * Creates a shortcut function to a hasher's object interface.
			 *
			 * @param {Hasher} hasher The hasher to create a helper for.
			 *
			 * @return {Function} The shortcut function.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
			 */
			_createHelper: function (hasher) {
				return function (message, cfg) {
					return new hasher.init(cfg).finalize(message);
				};
			},

			/**
			 * Creates a shortcut function to the HMAC's object interface.
			 *
			 * @param {Hasher} hasher The hasher to use in this HMAC helper.
			 *
			 * @return {Function} The shortcut function.
			 *
			 * @static
			 *
			 * @example
			 *
			 *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
			 */
			_createHmacHelper: function (hasher) {
				return function (message, key) {
					return new C_algo.HMAC.init(hasher, key).finalize(message);
				};
			}
		});

		/**
		 * Algorithm namespace.
		 */
		var C_algo = C.algo = {};

		return C;
	}(Math));
}(self));

/*
CryptoJS v3.1.2
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License

*/
(function () {
	'use strict';

	// Shortcuts
	var C = CryptoJS;
	var C_lib = C.lib;
	var WordArray = C_lib.WordArray;
	var Hasher = C_lib.Hasher;
	var C_algo = C.algo;

	// Reusable object
	var W = [];

	/**
	 * SHA-1 hash algorithm.
	 */
	var SHA1 = C_algo.SHA1 = Hasher.extend({
		_doReset: function () {
			this._hash = new WordArray.init([
				0x67452301, 0xefcdab89,
				0x98badcfe, 0x10325476,
				0xc3d2e1f0
			]);
		},

		_doProcessBlock: function (M, offset) {
			// Shortcut
			var H = this._hash.words;

			// Working variables
			var a = H[0];
			var b = H[1];
			var c = H[2];
			var d = H[3];
			var e = H[4];

			// Computation
			for (var i = 0; i < 80; i++) {
				if (i < 16) {
					W[i] = M[offset + i] | 0;
				} else {
					var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
					W[i] = (n << 1) | (n >>> 31);
				}

				var t = ((a << 5) | (a >>> 27)) + e + W[i];
				if (i < 20) {
					t += ((b & c) | (~b & d)) + 0x5a827999;
				} else if (i < 40) {
					t += (b ^ c ^ d) + 0x6ed9eba1;
				} else if (i < 60) {
					t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
				} else /* if (i < 80) */ {
					t += (b ^ c ^ d) - 0x359d3e2a;
				}

				e = d;
				d = c;
				c = (b << 30) | (b >>> 2);
				b = a;
				a = t;
			}

			// Intermediate hash value
			H[0] = (H[0] + a) | 0;
			H[1] = (H[1] + b) | 0;
			H[2] = (H[2] + c) | 0;
			H[3] = (H[3] + d) | 0;
			H[4] = (H[4] + e) | 0;
		},

		_doFinalize: function () {
			// Shortcuts
			var data = this._data;
			var dataWords = data.words;

			var nBitsTotal = this._nDataBytes * 8;
			var nBitsLeft = data.sigBytes * 8;
			var lastIndex = ((((nBitsLeft + 64) >>> 9) << 4) + 15);

			// Check whether there is enough memory
			if (dataWords.length < lastIndex + 1) {
				// No, re-allocate fresh memory
				var tmp = new Int32Array(lastIndex + 1);
				tmp.set(dataWords);
				this._data.words = dataWords = tmp;
			}

			// Add padding (rfc3174)
			// As a summary, a "1" followed by m "0"s
			// WARNING: OVERFLOW; allocate more memory on demand
			dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);

			// followed by a 64-bit integer are appended to the end
			// of the message to produce a padded message of length 512 * n. 
			// The 64-bit integer is the length of the original message.
			dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
			dataWords[lastIndex] = nBitsTotal;

			data.sigBytes = (lastIndex + 1) * 4;

			// Hash final blocks
			this._process();

			// Return final computed hash
			return this._hash;
		},

		clone: function () {
			var clone = Hasher.clone.call(this);
			clone._hash = this._hash.clone();

			return clone;
		}
	});

	/**
	 * Shortcut function to the hasher's object interface.
	 *
	 * @param {WordArray|string} message The message to hash.
	 *
	 * @return {WordArray} The hash.
	 *
	 * @static
	 *
	 * @example
	 *
	 *     var hash = CryptoJS.SHA1('message');
	 *     var hash = CryptoJS.SHA1(wordArray);
	 */
	C.SHA1 = Hasher._createHelper(SHA1);

	/**
	 * Shortcut function to the HMAC's object interface.
	 *
	 * @param {WordArray|string} message The message to hash.
	 * @param {WordArray|string} key The secret key.
	 *
	 * @return {WordArray} The HMAC.
	 *
	 * @static
	 *
	 * @example
	 *
	 *     var hmac = CryptoJS.HmacSHA1(message, key);
	 */
	C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
}());