├── .gitignore ├── index.js ├── .travis.yml ├── appveyor.yml ├── package.json ├── index.d.ts ├── LICENSE.md ├── binding.gyp ├── src ├── metrohash.h ├── metrohash128crc.h ├── platform.h ├── testvector.h ├── metrohash128.h ├── metrohash64.h ├── metrohash_wrapper.cpp ├── metrohash128crc.cpp ├── metrohash64.cpp └── metrohash128.cpp ├── benchmark.js ├── README.md └── test.js /.gitignore: -------------------------------------------------------------------------------- 1 | MetroHash 2 | node_modules 3 | build 4 | .vscode -------------------------------------------------------------------------------- /index.js: -------------------------------------------------------------------------------- 1 | module.exports = require('bindings')('metrohash.node'); 2 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | language: node_js 2 | 3 | node_js: 4 | - "node" 5 | - "16" 6 | - "14" 7 | - "12" 8 | - "10" 9 | 10 | branches: 11 | only: 12 | - master 13 | 14 | before_install: 15 | - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test 16 | - sudo apt-get update -qq 17 | - sudo apt-get install -qq g++-9 18 | - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 50 19 | -------------------------------------------------------------------------------- /appveyor.yml: -------------------------------------------------------------------------------- 1 | clone_depth: 10 2 | 3 | environment: 4 | matrix: 5 | - nodejs_version: 10 6 | - nodejs_version: 12 7 | - nodejs_version: 14 8 | - nodejs_version: 16 9 | 10 | matrix: 11 | fast_finish: true 12 | 13 | platform: 14 | - x64 15 | 16 | branches: 17 | only: 18 | - master 19 | 20 | version: "{build}" 21 | build: off 22 | deploy: off 23 | 24 | install: 25 | - ps: Install-Product node $env:nodejs_version $env:platform 26 | - npm install 27 | 28 | test_script: 29 | - npm test 30 | 31 | cache: 32 | # global npm cache 33 | - '%APPDATA%\npm-cache' 34 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "metrohash", 3 | "version": "3.0.0", 4 | "description": "Node.js bindings for MetroHash hashing library", 5 | "scripts": { 6 | "build": "node-gyp rebuild", 7 | "rebuild": "node-gyp rebuild", 8 | "test": "mocha test.js" 9 | }, 10 | "main": "index.js", 11 | "types": "index.d.ts", 12 | "gypfile": true, 13 | "author": "Robert Klep ", 14 | "repository": "robertklep/node-metrohash", 15 | "license": "MIT", 16 | "dependencies": { 17 | "bindings": "^1.5.0", 18 | "nan": "^2.22.0", 19 | "node-gyp": "^10.3.1" 20 | }, 21 | "devDependencies": { 22 | "chai": "^3.5.0", 23 | "mocha": "^11.0.1" 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /index.d.ts: -------------------------------------------------------------------------------- 1 | /// 2 | 3 | interface MetroHasher { 4 | // Update. 5 | update(input: string | Buffer): this; 6 | 7 | // Finalize and get hash digest. 8 | digest(): string; 9 | } 10 | 11 | export class MetroHash64 implements MetroHasher { 12 | // Constructor. 13 | constructor(seed?: number); 14 | 15 | // Update. 16 | update(input: string | Buffer): this; 17 | 18 | // Finalize and get hash digest. 19 | digest(): string; 20 | } 21 | 22 | export class MetroHash128 implements MetroHasher { 23 | // Constructor. 24 | constructor(seed?: number); 25 | 26 | // Update. 27 | update(input: string | Buffer): this; 28 | 29 | // Finalize and get hash digest. 30 | digest(): string; 31 | } 32 | 33 | export function metrohash64(input: string | Buffer, seed?: number): string; 34 | 35 | export function metrohash128(input: string | Buffer, seed?: number): string; 36 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 Robert Klep 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /binding.gyp: -------------------------------------------------------------------------------- 1 | { 2 | "targets": [{ 3 | "target_name" : "metrohash", 4 | "sources" : [ "./src/metrohash_wrapper.cpp", "./src/metrohash128.cpp", "./src/metrohash128crc.cpp", "./src/metrohash64.cpp" ], 5 | "cflags" : [ "-std=c++11 -Wno-deprecated-declarations -Wno-unused-value -Wno-unused-function -Wno-unknown-pragmas -Wno-format -msse4.2" ], 6 | "include_dirs" : [ " { 20 | 21 | for (const test of TESTS) { 22 | 23 | suite(test.name, () => { 24 | 25 | benchmark('MetroHash64', () => { 26 | let hasher = new MetroHash64(); 27 | hasher.update(test.input); 28 | return hasher.digest(); 29 | }); 30 | 31 | benchmark('MetroHash128', () => { 32 | let hasher = new MetroHash128(); 33 | hasher.update(test.input); 34 | return hasher.digest(); 35 | }); 36 | 37 | benchmark('metrohash64', () => { 38 | return metrohash64(test.input); 39 | }); 40 | 41 | benchmark('metrohash128', () => { 42 | return metrohash128(test.input); 43 | }); 44 | 45 | }); 46 | } 47 | 48 | } 49 | -------------------------------------------------------------------------------- /src/metrohash128crc.h: -------------------------------------------------------------------------------- 1 | // metrohash128crc.h 2 | // 3 | // The MIT License (MIT) 4 | // 5 | // Copyright (c) 2015 J. Andrew Rogers 6 | // 7 | // Permission is hereby granted, free of charge, to any person obtaining a copy 8 | // of this software and associated documentation files (the "Software"), to deal 9 | // in the Software without restriction, including without limitation the rights 10 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | // copies of the Software, and to permit persons to whom the Software is 12 | // furnished to do so, subject to the following conditions: 13 | // 14 | // The above copyright notice and this permission notice shall be included in all 15 | // copies or substantial portions of the Software. 16 | // 17 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | // SOFTWARE. 24 | // 25 | 26 | #ifndef METROHASH_METROHASH_128_CRC_H 27 | #define METROHASH_METROHASH_128_CRC_H 28 | 29 | #include 30 | 31 | // Legacy 128-bit hash functions 32 | void metrohash128crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 33 | void metrohash128crc_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 34 | 35 | 36 | #endif // #ifndef METROHASH_METROHASH_128_CRC_H 37 | -------------------------------------------------------------------------------- /src/platform.h: -------------------------------------------------------------------------------- 1 | // platform.h 2 | // 3 | // The MIT License (MIT) 4 | // 5 | // Copyright (c) 2015 J. Andrew Rogers 6 | // 7 | // Permission is hereby granted, free of charge, to any person obtaining a copy 8 | // of this software and associated documentation files (the "Software"), to deal 9 | // in the Software without restriction, including without limitation the rights 10 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | // copies of the Software, and to permit persons to whom the Software is 12 | // furnished to do so, subject to the following conditions: 13 | // 14 | // The above copyright notice and this permission notice shall be included in all 15 | // copies or substantial portions of the Software. 16 | // 17 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | // SOFTWARE. 24 | // 25 | 26 | #ifndef METROHASH_PLATFORM_H 27 | #define METROHASH_PLATFORM_H 28 | 29 | #include 30 | 31 | // rotate right idiom recognized by most compilers 32 | inline static uint64_t rotate_right(uint64_t v, unsigned k) 33 | { 34 | return (v >> k) | (v << (64 - k)); 35 | } 36 | 37 | // unaligned reads, fast and safe on Nehalem and later microarchitectures 38 | inline static uint64_t read_u64(const void * const ptr) 39 | { 40 | return static_cast(*reinterpret_cast(ptr)); 41 | } 42 | 43 | inline static uint64_t read_u32(const void * const ptr) 44 | { 45 | return static_cast(*reinterpret_cast(ptr)); 46 | } 47 | 48 | inline static uint64_t read_u16(const void * const ptr) 49 | { 50 | return static_cast(*reinterpret_cast(ptr)); 51 | } 52 | 53 | inline static uint64_t read_u8 (const void * const ptr) 54 | { 55 | return static_cast(*reinterpret_cast(ptr)); 56 | } 57 | 58 | 59 | #endif // #ifndef METROHASH_PLATFORM_H 60 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # node-metrohash 2 | 3 | Wrapper around [MetroHash](https://github.com/jandrewrogers/MetroHash). 4 | 5 | [![Build Status](https://travis-ci.org/robertklep/node-metrohash.svg)](https://travis-ci.org/robertklep/node-metrohash) 6 | [![Build status](https://ci.appveyor.com/api/projects/status/49944yng9l70q41k/branch/master?svg=true)](https://ci.appveyor.com/project/robertklep/node-metrohash/branch/master) 7 | 8 | ### Installation 9 | 10 | ``` 11 | $ npm install metrohash 12 | ``` 13 | 14 | ### API change! 15 | 16 | Between v1 and v2, the API for this library has changed to allow for maximum hashing speed. 17 | 18 | The biggest change is that a calculated hash is now returned as a (hex-encoded) string instead of a `Buffer`. 19 | 20 | If a `Buffer` is still required, it's easy to convert the string: 21 | 22 | ``` 23 | let buffer = Buffer.from(metrohash64('input'), 'hex'); 24 | ``` 25 | 26 | Also, the `.hash()` methods for the hasher classes have been removed in favor of standalone functions (see below). 27 | 28 | ### Usage 29 | 30 | The module exports 2 classes, `MetroHash64` and `MetroHash128`, and two functions, `metrohash64` and `metrohash128`. 31 | 32 | The classes are meant for incremental hashing, the functions for standalone hash calculations. 33 | 34 | The class constructors and functions accept an optional `seed` numerical argument, which defaults to `0`. 35 | 36 | #### Class interface 37 | 38 | ``` javascript 39 | const MetroHash64 = require('metrohash').MetroHash64; 40 | 41 | // Constructor. 42 | MetroHash64(seed? : number) : this 43 | 44 | // Update. 45 | MetroHash64#update(input : String | Buffer) : this 46 | 47 | // Finalize and get hash digest. 48 | MetroHash64#digest() : String 49 | ``` 50 | 51 | (likewise for `MetroHash128`). 52 | 53 | #### Function interface 54 | 55 | ``` 56 | const metrohash64 = require('metrohash').metrohash64; 57 | 58 | metrohash64(input : String | Buffer, seed? : number) : String 59 | ``` 60 | 61 | (likewise for `metrohash128`). 62 | 63 | ### Examples 64 | 65 | ``` javascript 66 | //// Classes 67 | 68 | const MetroHash64 = require('metrohash').MetroHash64; 69 | 70 | // Instantiate using seed 123 (`new` is optional). 71 | let hash = new MetroHash64(123); 72 | 73 | // Update using a string as input. 74 | hash.update('Hello, World!'); 75 | 76 | // The same as above: 77 | // hash.update('Hello, ').update('World!'); 78 | 79 | // Finalize to get the digest as a hex string. 80 | let digest = hash.digest(); 81 | 82 | //// Functions 83 | const metrohash64 = require('metrohash').metrohash64; 84 | 85 | let digest = metrohash64('Hello, World!', 123); 86 | ``` 87 | 88 | ### Speed 89 | 90 | From v2.0 onwards, MetroHash is [pretty fast](https://medium.com/@drainingsun/in-search-of-a-good-node-js-hashing-algorithm-8052b6923a3b). 91 | -------------------------------------------------------------------------------- /src/testvector.h: -------------------------------------------------------------------------------- 1 | // testvector.h 2 | // 3 | // The MIT License (MIT) 4 | // 5 | // Copyright (c) 2015 J. Andrew Rogers 6 | // 7 | // Permission is hereby granted, free of charge, to any person obtaining a copy 8 | // of this software and associated documentation files (the "Software"), to deal 9 | // in the Software without restriction, including without limitation the rights 10 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | // copies of the Software, and to permit persons to whom the Software is 12 | // furnished to do so, subject to the following conditions: 13 | // 14 | // The above copyright notice and this permission notice shall be included in all 15 | // copies or substantial portions of the Software. 16 | // 17 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | // SOFTWARE. 24 | // 25 | 26 | #ifndef METROHASH_TESTVECTOR_H 27 | #define METROHASH_TESTVECTOR_H 28 | 29 | #include "metrohash.h" 30 | 31 | 32 | typedef void (*HashFunction) (const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * hash); 33 | 34 | struct TestVectorData 35 | { 36 | HashFunction function; 37 | uint32_t bits; 38 | const char * key; 39 | uint32_t seed; 40 | uint8_t hash[64]; 41 | }; 42 | 43 | // The test vector string is selected such that it will properly exercise every 44 | // internal branch of the hash function. Currently that requires a string with 45 | // a length of (at least) 63 bytes. 46 | 47 | static const char * test_key_63 = "012345678901234567890123456789012345678901234567890123456789012"; 48 | 49 | // The hash assumes a little-endian architecture. Treating the hash results 50 | // as an array of uint64_t should enable conversion for big-endian implementations. 51 | const TestVectorData TestVector [] = 52 | { 53 | // seed = 0 54 | { metrohash64_1, 64, test_key_63, 0, "658F044F5C730E40" }, 55 | { metrohash64_2, 64, test_key_63, 0, "073CAAB960623211" }, 56 | { metrohash128_1, 128, test_key_63, 0, "ED9997ED9D0A8B0FF3F266399477788F" }, 57 | { metrohash128_2, 128, test_key_63, 0, "7BBA6FE119CF35D45507EDF3505359AB" }, 58 | { metrohash128crc_1, 128, test_key_63, 0, "B329ED67831604D3DFAC4E4876D8262F" }, 59 | { metrohash128crc_2, 128, test_key_63, 0, "0502A67E257BBD77206BBCA6BBEF2653" }, 60 | 61 | // seed = 1 62 | { metrohash64_1, 64, test_key_63, 1, "AE49EBB0A856537B" }, 63 | { metrohash64_2, 64, test_key_63, 1, "CF518E9CF58402C0" }, 64 | { metrohash128_1, 128, test_key_63, 1, "DDA6BA67F7DE755EFDF6BEABECCFD1F4" }, 65 | { metrohash128_2, 128, test_key_63, 1, "2DA6AF149A5CDBC12B09DB0846D69EF0" }, 66 | { metrohash128crc_1, 128, test_key_63, 1, "E8FAB51AF19F18A7B10D0A57D4276DF2" }, 67 | { metrohash128crc_2, 128, test_key_63, 1, "2D54F87181A0CF64B02C50D95692BC19" }, 68 | }; 69 | 70 | 71 | 72 | #endif // #ifndef METROHASH_TESTVECTOR_H 73 | -------------------------------------------------------------------------------- /src/metrohash128.h: -------------------------------------------------------------------------------- 1 | // metrohash128.h 2 | // 3 | // The MIT License (MIT) 4 | // 5 | // Copyright (c) 2015 J. Andrew Rogers 6 | // 7 | // Permission is hereby granted, free of charge, to any person obtaining a copy 8 | // of this software and associated documentation files (the "Software"), to deal 9 | // in the Software without restriction, including without limitation the rights 10 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | // copies of the Software, and to permit persons to whom the Software is 12 | // furnished to do so, subject to the following conditions: 13 | // 14 | // The above copyright notice and this permission notice shall be included in all 15 | // copies or substantial portions of the Software. 16 | // 17 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | // SOFTWARE. 24 | // 25 | 26 | #ifndef METROHASH_METROHASH_128_H 27 | #define METROHASH_METROHASH_128_H 28 | 29 | #include 30 | 31 | class MetroHash128 32 | { 33 | public: 34 | static const uint32_t bits = 128; 35 | 36 | // Constructor initializes the same as Initialize() 37 | MetroHash128(const uint64_t seed=0); 38 | 39 | // Initializes internal state for new hash with optional seed 40 | void Initialize(const uint64_t seed=0); 41 | 42 | // Update the hash state with a string of bytes. If the length 43 | // is sufficiently long, the implementation switches to a bulk 44 | // hashing algorithm directly on the argument buffer for speed. 45 | void Update(const uint8_t * buffer, const uint64_t length); 46 | 47 | // Constructs the final hash and writes it to the argument buffer. 48 | // After a hash is finalized, this instance must be Initialized()-ed 49 | // again or the behavior of Update() and Finalize() is undefined. 50 | void Finalize(uint8_t * const hash); 51 | 52 | // A non-incremental function implementation. This can be significantly 53 | // faster than the incremental implementation for some usage patterns. 54 | static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0); 55 | 56 | // Does implementation correctly execute test vectors? 57 | static bool ImplementationVerified(); 58 | 59 | // test vectors -- Hash(test_string, seed=0) => test_seed_0 60 | static const char * test_string; 61 | static const uint8_t test_seed_0[16]; 62 | static const uint8_t test_seed_1[16]; 63 | 64 | private: 65 | static const uint64_t k0 = 0xC83A91E1; 66 | static const uint64_t k1 = 0x8648DBDB; 67 | static const uint64_t k2 = 0x7BDEC03B; 68 | static const uint64_t k3 = 0x2F5870A5; 69 | 70 | struct { uint64_t v[4]; } state; 71 | struct { uint8_t b[32]; } input; 72 | uint64_t bytes; 73 | }; 74 | 75 | 76 | // Legacy 128-bit hash functions -- do not use 77 | void metrohash128_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 78 | void metrohash128_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 79 | 80 | 81 | #endif // #ifndef METROHASH_METROHASH_128_H 82 | -------------------------------------------------------------------------------- /src/metrohash64.h: -------------------------------------------------------------------------------- 1 | // metrohash64.h 2 | // 3 | // The MIT License (MIT) 4 | // 5 | // Copyright (c) 2015 J. Andrew Rogers 6 | // 7 | // Permission is hereby granted, free of charge, to any person obtaining a copy 8 | // of this software and associated documentation files (the "Software"), to deal 9 | // in the Software without restriction, including without limitation the rights 10 | // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | // copies of the Software, and to permit persons to whom the Software is 12 | // furnished to do so, subject to the following conditions: 13 | // 14 | // The above copyright notice and this permission notice shall be included in all 15 | // copies or substantial portions of the Software. 16 | // 17 | // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 23 | // SOFTWARE. 24 | // 25 | 26 | #ifndef METROHASH_METROHASH_64_H 27 | #define METROHASH_METROHASH_64_H 28 | 29 | #include 30 | 31 | class MetroHash64 32 | { 33 | public: 34 | static const uint32_t bits = 64; 35 | 36 | // Constructor initializes the same as Initialize() 37 | MetroHash64(const uint64_t seed=0); 38 | 39 | // Initializes internal state for new hash with optional seed 40 | void Initialize(const uint64_t seed=0); 41 | 42 | // Update the hash state with a string of bytes. If the length 43 | // is sufficiently long, the implementation switches to a bulk 44 | // hashing algorithm directly on the argument buffer for speed. 45 | void Update(const uint8_t * buffer, const uint64_t length); 46 | 47 | // Constructs the final hash and writes it to the argument buffer. 48 | // After a hash is finalized, this instance must be Initialized()-ed 49 | // again or the behavior of Update() and Finalize() is undefined. 50 | void Finalize(uint8_t * const hash); 51 | 52 | // A non-incremental function implementation. This can be significantly 53 | // faster than the incremental implementation for some usage patterns. 54 | static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0); 55 | 56 | // Does implementation correctly execute test vectors? 57 | static bool ImplementationVerified(); 58 | 59 | // test vectors -- Hash(test_string, seed=0) => test_seed_0 60 | static const char * test_string; 61 | static const uint8_t test_seed_0[8]; 62 | static const uint8_t test_seed_1[8]; 63 | 64 | private: 65 | static const uint64_t k0 = 0xD6D018F5; 66 | static const uint64_t k1 = 0xA2AA033B; 67 | static const uint64_t k2 = 0x62992FC1; 68 | static const uint64_t k3 = 0x30BC5B29; 69 | 70 | struct { uint64_t v[4]; } state; 71 | struct { uint8_t b[32]; } input; 72 | uint64_t bytes; 73 | uint64_t vseed; 74 | }; 75 | 76 | 77 | // Legacy 64-bit hash functions -- do not use 78 | void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 79 | void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out); 80 | 81 | 82 | #endif // #ifndef METROHASH_METROHASH_64_H 83 | -------------------------------------------------------------------------------- /test.js: -------------------------------------------------------------------------------- 1 | 'use strict'; 2 | var MetroHash64 = require('./index').MetroHash64; 3 | var MetroHash128 = require('./index').MetroHash128; 4 | var metrohash64 = require('./index').metrohash64; 5 | var metrohash128 = require('./index').metrohash128; 6 | var expect = require('chai').expect; 7 | 8 | const TESTVECTOR_S = '012345678901234567890123456789012345678901234567890123456789012'; 9 | const TESTVECTOR_B = Buffer.from(TESTVECTOR_S); 10 | 11 | const CLS_TESTS = [ 12 | { cls : MetroHash64, expected : '6b753dae06704bad' }, 13 | { cls : MetroHash64, seed : 0, expected : '6b753dae06704bad' }, 14 | { cls : MetroHash64, seed : 1, expected : '3b0d481cf4b9b8df' }, 15 | { cls : MetroHash128, expected : 'c77ce2bfa4ed9f9b0548b2ac5074a297' }, 16 | { cls : MetroHash128, seed : 0, expected : 'c77ce2bfa4ed9f9b0548b2ac5074a297' }, 17 | { cls : MetroHash128, seed : 1, expected : '45a3cdb838199d7fbdd68d867a14ecef' }, 18 | ]; 19 | 20 | const FUN_TESTS = [ 21 | { fn : metrohash64, expected : '6b753dae06704bad' }, 22 | { fn : metrohash64, seed : 0, expected : '6b753dae06704bad' }, 23 | { fn : metrohash64, seed : 1, expected : '3b0d481cf4b9b8df' }, 24 | { fn : metrohash128, expected : 'c77ce2bfa4ed9f9b0548b2ac5074a297' }, 25 | { fn : metrohash128, seed : 0, expected : 'c77ce2bfa4ed9f9b0548b2ac5074a297' }, 26 | { fn : metrohash128, seed : 1, expected : '45a3cdb838199d7fbdd68d867a14ecef' }, 27 | ]; 28 | 29 | describe('Instantiation and method calling', function() { 30 | 31 | it('new MetroHash64() should work', function() { 32 | expect(function() { new MetroHash64(); }).to.not.throw(); 33 | }); 34 | 35 | it('MetroHash64() should work', function() { 36 | expect(function() { MetroHash64(); }).to.not.throw(); 37 | }); 38 | 39 | it('new MetroHash128() should work', function() { 40 | expect(function() { new MetroHash128(); }).to.not.throw(); 41 | }); 42 | 43 | it('MetroHash128() should work', function() { 44 | expect(function() { MetroHash128(); }).to.not.throw(); 45 | }); 46 | 47 | it('MetroHash64() should allow chaining', function() { 48 | expect(function() { 49 | new MetroHash64().update(TESTVECTOR_B).digest(); 50 | }).to.not.throw(); 51 | }); 52 | 53 | it('MetroHash128() should allow chaining', function() { 54 | expect(function() { 55 | new MetroHash128().update(TESTVECTOR_B).digest(); 56 | }).to.not.throw(); 57 | }); 58 | 59 | }); 60 | 61 | describe('Test vectors', function() { 62 | 63 | CLS_TESTS.forEach(function(test) { 64 | var suffix = test.seed !== undefined ? ', seed = ' + test.seed + ')' : ')'; 65 | 66 | it('new ' + test.cls.name + '(String' + suffix, function() { 67 | var instance = new test.cls(test.seed); 68 | instance.update(TESTVECTOR_S); 69 | expect(instance.digest()).to.equal(test.expected); 70 | }); 71 | 72 | it(test.cls.name + '(String' + suffix, function() { 73 | var instance = test.cls(test.seed); 74 | instance.update(TESTVECTOR_S); 75 | expect(instance.digest()).to.equal(test.expected); 76 | }); 77 | 78 | it('new ' + test.cls.name + '(Buffer' + suffix, function() { 79 | var instance = new test.cls(test.seed); 80 | instance.update(TESTVECTOR_B); 81 | expect(instance.digest()).to.equal(test.expected); 82 | }); 83 | 84 | it(test.cls.name + '(Buffer' + suffix, function() { 85 | var instance = test.cls(test.seed); 86 | instance.update(TESTVECTOR_B); 87 | expect(instance.digest()).to.equal(test.expected); 88 | }); 89 | 90 | it(test.cls.name + '(String' + suffix + ' incremental', function() { 91 | var instance = test.cls(test.seed); 92 | TESTVECTOR_S.split('').forEach(function(c) { 93 | instance.update(c); 94 | }); 95 | expect(instance.digest()).to.equal(test.expected); 96 | }); 97 | 98 | it(test.cls.name + '(Buffer' + suffix + ' incremental', function() { 99 | var instance = test.cls(test.seed); 100 | for (var i = 0; i < TESTVECTOR_B.length; i++) { 101 | instance.update(TESTVECTOR_B.slice(i, i + 1)); 102 | } 103 | expect(instance.digest()).to.equal(test.expected); 104 | }); 105 | }); 106 | 107 | FUN_TESTS.forEach(function(test) { 108 | let hasSeed = test.seed !== undefined; 109 | let suffix = hasSeed ? ', seed = ' + test.seed + ')' : ')'; 110 | 111 | it('Standalone: ' + test.fn.name + '(String' + suffix, function() { 112 | let result = hasSeed ? test.fn(TESTVECTOR_S, test.seed) : test.fn(TESTVECTOR_S); 113 | expect(result).to.equal(test.expected); 114 | }); 115 | 116 | it('Standalone: ' + test.fn.name + '(Buffer' + suffix, function() { 117 | let result = hasSeed ? test.fn(TESTVECTOR_B, test.seed) : test.fn(TESTVECTOR_B); 118 | expect(result).to.equal(test.expected); 119 | }); 120 | 121 | it('Standalone: ' + test.fn.name + ', handle invalid data', function() { 122 | expect(function() { test.fn(123) }).to.fail; 123 | }); 124 | 125 | it('Standalone: ' + test.fn.name + ', handle invalid seed', function() { 126 | expect(function() { test.fn(TESTVECTOR_S, 'foo') }).to.fail; 127 | }); 128 | 129 | it('Standalone: ' + test.fn.name + ', handle invalid data and seed', function() { 130 | expect(function() { test.fn(123, 'foo') }).to.fail; 131 | }); 132 | 133 | }); 134 | 135 | }); 136 | -------------------------------------------------------------------------------- /src/metrohash_wrapper.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "metrohash.h" 4 | 5 | using namespace v8; 6 | using namespace node; 7 | 8 | template 9 | class NodeMetroHash : public Nan::ObjectWrap { 10 | static Nan::Persistent constructor; 11 | HashClass metro; 12 | uint64_t seed; 13 | uint8_t digest[DIGEST_SIZE]; 14 | bool wasFinalized = false; 15 | 16 | explicit NodeMetroHash(uint64_t seed = 0) : seed(seed) { 17 | metro.Initialize(seed); 18 | } 19 | 20 | static NAN_METHOD(New) { 21 | Nan::HandleScope scope; 22 | if (info.IsConstructCall()) { 23 | // TODO: check if argument type makes sense 24 | NodeMetroHash* hash = new NodeMetroHash(info[0]->IsUndefined() ? 0 : Nan::To(info[0]).FromJust()); 25 | hash->Wrap(info.This()); 26 | info.GetReturnValue().Set(info.This()); 27 | } else { 28 | const int argc = 1; 29 | Local argv[argc] = { info[0] }; 30 | Local cons = Nan::New(constructor); 31 | info.GetReturnValue().Set(Nan::NewInstance(cons, argc, argv).ToLocalChecked()); 32 | } 33 | } 34 | 35 | static NAN_METHOD(Update) { 36 | Nan::HandleScope scope; 37 | NodeMetroHash* self = Nan::ObjectWrap::Unwrap(info.This()); 38 | 39 | // Argument validation. 40 | if (info.Length() != 1) { 41 | Nan::ThrowTypeError("Missing argument"); 42 | return; 43 | } 44 | 45 | // Determine data and size of content to be hashed. 46 | char* data; 47 | size_t size; 48 | std::string str; 49 | if (Buffer::HasInstance(info[0])) { 50 | data = Buffer::Data(info[0]); 51 | size = Buffer::Length(info[0]); 52 | } else if (info[0]->IsString()) { 53 | str = *Nan::Utf8String(info[0]); 54 | data = (char *) str.c_str(); 55 | size = str.length(); 56 | } else { 57 | Nan::ThrowTypeError("`data` argument must be String or Buffer"); 58 | return; 59 | } 60 | 61 | // Update hash. 62 | self->metro.Update((const uint8_t *) data, size); 63 | 64 | // Allow for chaining. 65 | info.GetReturnValue().Set(info.This()); 66 | } 67 | 68 | static NAN_METHOD(Digest) { 69 | Nan::HandleScope scope; 70 | NodeMetroHash* self = Nan::ObjectWrap::Unwrap(info.This()); 71 | 72 | // Finalize and get the hash value. Make sure we only finalize once. 73 | if (! self->wasFinalized) { 74 | self->metro.Finalize(self->digest); 75 | self->wasFinalized = true; 76 | } 77 | 78 | // Return as hex string. 79 | info.GetReturnValue().Set(Nan::Encode((char *) self->digest, DIGEST_SIZE, Nan::HEX)); 80 | } 81 | 82 | public: 83 | static void Init(const char *js_class_name, Local