Spaces:
Running
Running
| ; | |
| var crypto = require('crypto'); | |
| /** | |
| * Exported function | |
| * | |
| * Options: | |
| * | |
| * - `algorithm` hash algo to be used by this instance: *'sha1', 'md5' | |
| * - `excludeValues` {true|*false} hash object keys, values ignored | |
| * - `encoding` hash encoding, supports 'buffer', '*hex', 'binary', 'base64' | |
| * - `ignoreUnknown` {true|*false} ignore unknown object types | |
| * - `replacer` optional function that replaces values before hashing | |
| * - `respectFunctionProperties` {*true|false} consider function properties when hashing | |
| * - `respectFunctionNames` {*true|false} consider 'name' property of functions for hashing | |
| * - `respectType` {*true|false} Respect special properties (prototype, constructor) | |
| * when hashing to distinguish between types | |
| * - `unorderedArrays` {true|*false} Sort all arrays before hashing | |
| * - `unorderedSets` {*true|false} Sort `Set` and `Map` instances before hashing | |
| * * = default | |
| * | |
| * @param {object} object value to hash | |
| * @param {object} options hashing options | |
| * @return {string} hash value | |
| * @api public | |
| */ | |
| exports = module.exports = objectHash; | |
| function objectHash(object, options){ | |
| options = applyDefaults(object, options); | |
| return hash(object, options); | |
| } | |
| /** | |
| * Exported sugar methods | |
| * | |
| * @param {object} object value to hash | |
| * @return {string} hash value | |
| * @api public | |
| */ | |
| exports.sha1 = function(object){ | |
| return objectHash(object); | |
| }; | |
| exports.keys = function(object){ | |
| return objectHash(object, {excludeValues: true, algorithm: 'sha1', encoding: 'hex'}); | |
| }; | |
| exports.MD5 = function(object){ | |
| return objectHash(object, {algorithm: 'md5', encoding: 'hex'}); | |
| }; | |
| exports.keysMD5 = function(object){ | |
| return objectHash(object, {algorithm: 'md5', encoding: 'hex', excludeValues: true}); | |
| }; | |
| // Internals | |
| var hashes = crypto.getHashes ? crypto.getHashes().slice() : ['sha1', 'md5']; | |
| hashes.push('passthrough'); | |
| var encodings = ['buffer', 'hex', 'binary', 'base64']; | |
| function applyDefaults(object, sourceOptions){ | |
| sourceOptions = sourceOptions || {}; | |
| // create a copy rather than mutating | |
| var options = {}; | |
| options.algorithm = sourceOptions.algorithm || 'sha1'; | |
| options.encoding = sourceOptions.encoding || 'hex'; | |
| options.excludeValues = sourceOptions.excludeValues ? true : false; | |
| options.algorithm = options.algorithm.toLowerCase(); | |
| options.encoding = options.encoding.toLowerCase(); | |
| options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true; // default to false | |
| options.respectType = sourceOptions.respectType === false ? false : true; // default to true | |
| options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true; | |
| options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true; | |
| options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true; // default to false | |
| options.unorderedSets = sourceOptions.unorderedSets === false ? false : true; // default to false | |
| options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true; // default to true | |
| options.replacer = sourceOptions.replacer || undefined; | |
| options.excludeKeys = sourceOptions.excludeKeys || undefined; | |
| if(typeof object === 'undefined') { | |
| throw new Error('Object argument required.'); | |
| } | |
| // if there is a case-insensitive match in the hashes list, accept it | |
| // (i.e. SHA256 for sha256) | |
| for (var i = 0; i < hashes.length; ++i) { | |
| if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) { | |
| options.algorithm = hashes[i]; | |
| } | |
| } | |
| if(hashes.indexOf(options.algorithm) === -1){ | |
| throw new Error('Algorithm "' + options.algorithm + '" not supported. ' + | |
| 'supported values: ' + hashes.join(', ')); | |
| } | |
| if(encodings.indexOf(options.encoding) === -1 && | |
| options.algorithm !== 'passthrough'){ | |
| throw new Error('Encoding "' + options.encoding + '" not supported. ' + | |
| 'supported values: ' + encodings.join(', ')); | |
| } | |
| return options; | |
| } | |
| /** Check if the given function is a native function */ | |
| function isNativeFunction(f) { | |
| if ((typeof f) !== 'function') { | |
| return false; | |
| } | |
| var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i; | |
| return exp.exec(Function.prototype.toString.call(f)) != null; | |
| } | |
| function hash(object, options) { | |
| var hashingStream; | |
| if (options.algorithm !== 'passthrough') { | |
| hashingStream = crypto.createHash(options.algorithm); | |
| } else { | |
| hashingStream = new PassThrough(); | |
| } | |
| if (typeof hashingStream.write === 'undefined') { | |
| hashingStream.write = hashingStream.update; | |
| hashingStream.end = hashingStream.update; | |
| } | |
| var hasher = typeHasher(options, hashingStream); | |
| hasher.dispatch(object); | |
| if (!hashingStream.update) { | |
| hashingStream.end(''); | |
| } | |
| if (hashingStream.digest) { | |
| return hashingStream.digest(options.encoding === 'buffer' ? undefined : options.encoding); | |
| } | |
| var buf = hashingStream.read(); | |
| if (options.encoding === 'buffer') { | |
| return buf; | |
| } | |
| return buf.toString(options.encoding); | |
| } | |
| /** | |
| * Expose streaming API | |
| * | |
| * @param {object} object Value to serialize | |
| * @param {object} options Options, as for hash() | |
| * @param {object} stream A stream to write the serializiation to | |
| * @api public | |
| */ | |
| exports.writeToStream = function(object, options, stream) { | |
| if (typeof stream === 'undefined') { | |
| stream = options; | |
| options = {}; | |
| } | |
| options = applyDefaults(object, options); | |
| return typeHasher(options, stream).dispatch(object); | |
| }; | |
| function typeHasher(options, writeTo, context){ | |
| context = context || []; | |
| var write = function(str) { | |
| if (writeTo.update) { | |
| return writeTo.update(str, 'utf8'); | |
| } else { | |
| return writeTo.write(str, 'utf8'); | |
| } | |
| }; | |
| return { | |
| dispatch: function(value){ | |
| if (options.replacer) { | |
| value = options.replacer(value); | |
| } | |
| var type = typeof value; | |
| if (value === null) { | |
| type = 'null'; | |
| } | |
| //console.log("[DEBUG] Dispatch: ", value, "->", type, " -> ", "_" + type); | |
| return this['_' + type](value); | |
| }, | |
| _object: function(object) { | |
| var pattern = (/\[object (.*)\]/i); | |
| var objString = Object.prototype.toString.call(object); | |
| var objType = pattern.exec(objString); | |
| if (!objType) { // object type did not match [object ...] | |
| objType = 'unknown:[' + objString + ']'; | |
| } else { | |
| objType = objType[1]; // take only the class name | |
| } | |
| objType = objType.toLowerCase(); | |
| var objectNumber = null; | |
| if ((objectNumber = context.indexOf(object)) >= 0) { | |
| return this.dispatch('[CIRCULAR:' + objectNumber + ']'); | |
| } else { | |
| context.push(object); | |
| } | |
| if (typeof Buffer !== 'undefined' && Buffer.isBuffer && Buffer.isBuffer(object)) { | |
| write('buffer:'); | |
| return write(object); | |
| } | |
| if(objType !== 'object' && objType !== 'function' && objType !== 'asyncfunction') { | |
| if(this['_' + objType]) { | |
| this['_' + objType](object); | |
| } else if (options.ignoreUnknown) { | |
| return write('[' + objType + ']'); | |
| } else { | |
| throw new Error('Unknown object type "' + objType + '"'); | |
| } | |
| }else{ | |
| var keys = Object.keys(object); | |
| if (options.unorderedObjects) { | |
| keys = keys.sort(); | |
| } | |
| // Make sure to incorporate special properties, so | |
| // Types with different prototypes will produce | |
| // a different hash and objects derived from | |
| // different functions (`new Foo`, `new Bar`) will | |
| // produce different hashes. | |
| // We never do this for native functions since some | |
| // seem to break because of that. | |
| if (options.respectType !== false && !isNativeFunction(object)) { | |
| keys.splice(0, 0, 'prototype', '__proto__', 'constructor'); | |
| } | |
| if (options.excludeKeys) { | |
| keys = keys.filter(function(key) { return !options.excludeKeys(key); }); | |
| } | |
| write('object:' + keys.length + ':'); | |
| var self = this; | |
| return keys.forEach(function(key){ | |
| self.dispatch(key); | |
| write(':'); | |
| if(!options.excludeValues) { | |
| self.dispatch(object[key]); | |
| } | |
| write(','); | |
| }); | |
| } | |
| }, | |
| _array: function(arr, unordered){ | |
| unordered = typeof unordered !== 'undefined' ? unordered : | |
| options.unorderedArrays !== false; // default to options.unorderedArrays | |
| var self = this; | |
| write('array:' + arr.length + ':'); | |
| if (!unordered || arr.length <= 1) { | |
| return arr.forEach(function(entry) { | |
| return self.dispatch(entry); | |
| }); | |
| } | |
| // the unordered case is a little more complicated: | |
| // since there is no canonical ordering on objects, | |
| // i.e. {a:1} < {a:2} and {a:1} > {a:2} are both false, | |
| // we first serialize each entry using a PassThrough stream | |
| // before sorting. | |
| // also: we can’t use the same context array for all entries | |
| // since the order of hashing should *not* matter. instead, | |
| // we keep track of the additions to a copy of the context array | |
| // and add all of them to the global context array when we’re done | |
| var contextAdditions = []; | |
| var entries = arr.map(function(entry) { | |
| var strm = new PassThrough(); | |
| var localContext = context.slice(); // make copy | |
| var hasher = typeHasher(options, strm, localContext); | |
| hasher.dispatch(entry); | |
| // take only what was added to localContext and append it to contextAdditions | |
| contextAdditions = contextAdditions.concat(localContext.slice(context.length)); | |
| return strm.read().toString(); | |
| }); | |
| context = context.concat(contextAdditions); | |
| entries.sort(); | |
| return this._array(entries, false); | |
| }, | |
| _date: function(date){ | |
| return write('date:' + date.toJSON()); | |
| }, | |
| _symbol: function(sym){ | |
| return write('symbol:' + sym.toString()); | |
| }, | |
| _error: function(err){ | |
| return write('error:' + err.toString()); | |
| }, | |
| _boolean: function(bool){ | |
| return write('bool:' + bool.toString()); | |
| }, | |
| _string: function(string){ | |
| write('string:' + string.length + ':'); | |
| write(string.toString()); | |
| }, | |
| _function: function(fn){ | |
| write('fn:'); | |
| if (isNativeFunction(fn)) { | |
| this.dispatch('[native]'); | |
| } else { | |
| this.dispatch(fn.toString()); | |
| } | |
| if (options.respectFunctionNames !== false) { | |
| // Make sure we can still distinguish native functions | |
| // by their name, otherwise String and Function will | |
| // have the same hash | |
| this.dispatch("function-name:" + String(fn.name)); | |
| } | |
| if (options.respectFunctionProperties) { | |
| this._object(fn); | |
| } | |
| }, | |
| _number: function(number){ | |
| return write('number:' + number.toString()); | |
| }, | |
| _xml: function(xml){ | |
| return write('xml:' + xml.toString()); | |
| }, | |
| _null: function() { | |
| return write('Null'); | |
| }, | |
| _undefined: function() { | |
| return write('Undefined'); | |
| }, | |
| _regexp: function(regex){ | |
| return write('regex:' + regex.toString()); | |
| }, | |
| _uint8array: function(arr){ | |
| write('uint8array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _uint8clampedarray: function(arr){ | |
| write('uint8clampedarray:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _int8array: function(arr){ | |
| write('int8array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _uint16array: function(arr){ | |
| write('uint16array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _int16array: function(arr){ | |
| write('int16array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _uint32array: function(arr){ | |
| write('uint32array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _int32array: function(arr){ | |
| write('int32array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _float32array: function(arr){ | |
| write('float32array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _float64array: function(arr){ | |
| write('float64array:'); | |
| return this.dispatch(Array.prototype.slice.call(arr)); | |
| }, | |
| _arraybuffer: function(arr){ | |
| write('arraybuffer:'); | |
| return this.dispatch(new Uint8Array(arr)); | |
| }, | |
| _url: function(url) { | |
| return write('url:' + url.toString(), 'utf8'); | |
| }, | |
| _map: function(map) { | |
| write('map:'); | |
| var arr = Array.from(map); | |
| return this._array(arr, options.unorderedSets !== false); | |
| }, | |
| _set: function(set) { | |
| write('set:'); | |
| var arr = Array.from(set); | |
| return this._array(arr, options.unorderedSets !== false); | |
| }, | |
| _file: function(file) { | |
| write('file:'); | |
| return this.dispatch([file.name, file.size, file.type, file.lastModfied]); | |
| }, | |
| _blob: function() { | |
| if (options.ignoreUnknown) { | |
| return write('[blob]'); | |
| } | |
| throw Error('Hashing Blob objects is currently not supported\n' + | |
| '(see https://github.com/puleos/object-hash/issues/26)\n' + | |
| 'Use "options.replacer" or "options.ignoreUnknown"\n'); | |
| }, | |
| _domwindow: function() { return write('domwindow'); }, | |
| _bigint: function(number){ | |
| return write('bigint:' + number.toString()); | |
| }, | |
| /* Node.js standard native objects */ | |
| _process: function() { return write('process'); }, | |
| _timer: function() { return write('timer'); }, | |
| _pipe: function() { return write('pipe'); }, | |
| _tcp: function() { return write('tcp'); }, | |
| _udp: function() { return write('udp'); }, | |
| _tty: function() { return write('tty'); }, | |
| _statwatcher: function() { return write('statwatcher'); }, | |
| _securecontext: function() { return write('securecontext'); }, | |
| _connection: function() { return write('connection'); }, | |
| _zlib: function() { return write('zlib'); }, | |
| _context: function() { return write('context'); }, | |
| _nodescript: function() { return write('nodescript'); }, | |
| _httpparser: function() { return write('httpparser'); }, | |
| _dataview: function() { return write('dataview'); }, | |
| _signal: function() { return write('signal'); }, | |
| _fsevent: function() { return write('fsevent'); }, | |
| _tlswrap: function() { return write('tlswrap'); }, | |
| }; | |
| } | |
| // Mini-implementation of stream.PassThrough | |
| // We are far from having need for the full implementation, and we can | |
| // make assumptions like "many writes, then only one final read" | |
| // and we can ignore encoding specifics | |
| function PassThrough() { | |
| return { | |
| buf: '', | |
| write: function(b) { | |
| this.buf += b; | |
| }, | |
| end: function(b) { | |
| this.buf += b; | |
| }, | |
| read: function() { | |
| return this.buf; | |
| } | |
| }; | |
| } | |