Gathering detailed insights and metrics for @wemnyelezxnpm/accusamus-necessitatibus-autem
Gathering detailed insights and metrics for @wemnyelezxnpm/accusamus-necessitatibus-autem
Installations
npm install @wemnyelezxnpm/accusamus-necessitatibus-autemDeveloper Guide
BETA
Typescript
No
Module System
CommonJS
Node Version
20.12.2
NPM Version
10.5.0
Languages
1
JavaScript
JavaScript (100%)
Developer
wemnyelezxnpm
Download Statistics
Total Downloads
0
Last Day
0
Last Week
0
Last Month
0
Last Year
0
GitHub Statistics
MIT License
3 Commits
1 Branches
Updated on Apr 27, 2024
Maintainers
1
Package Meta Information
Latest Version
1.0.0
Package Id
@wemnyelezxnpm/accusamus-necessitatibus-autem@1.0.0
Unpacked Size
40.49 kB
Size
14.43 kB
File Count
10
NPM Version
10.5.0
Node Version
20.12.2
Published on
Apr 27, 2024
Total Downloads
Cumulative downloads
Total Downloads
NaN
Last Day
0%
NaN
Compared to previous day
Last Week
0%
NaN
Compared to previous week
Last Month
0%
NaN
Compared to previous month
Last Year
0%
NaN
Compared to previous year
Weekly Downloads
Monthly Downloads
Yearly Downloads
Dependencies
33
@crabas0npm/enim-animi-iure@ffras4vnpm/iste-soluta-repellendus@ffras4vnpm/ullam-odio-aspernatur@wemnyelezxnpm/a-illo-eos-qui@wemnyelezxnpm/aliquam-accusantium-porro-voluptates@wemnyelezxnpm/architecto-eligendi-ex-unde@wemnyelezxnpm/autem-est-molestias-numquam@wemnyelezxnpm/consectetur-eligendi-mollitia-enim@wemnyelezxnpm/consequatur-vel-distinctio-quia@wemnyelezxnpm/corrupti-voluptatem-pariatur-assumenda@wemnyelezxnpm/cum-assumenda-et-ad@wemnyelezxnpm/dolor-deserunt-reprehenderit-sunt@wemnyelezxnpm/esse-saepe-vero-excepturi@wemnyelezxnpm/ex-laudantium-dignissimos-nesciunt@wemnyelezxnpm/excepturi-odit-culpa-magnam@wemnyelezxnpm/facilis-velit-quam-ducimus@wemnyelezxnpm/illo-possimus-quas-ipsa@wemnyelezxnpm/illum-possimus-officiis-eius@wemnyelezxnpm/inventore-totam-iste-pariatur@wemnyelezxnpm/nam-sequi-vitae-eveniet@wemnyelezxnpm/nam-suscipit-commodi-nam@wemnyelezxnpm/odit-placeat-delectus-iure@wemnyelezxnpm/officiis-nesciunt-quisquam-delectus@wemnyelezxnpm/quas-quo-aperiam-quasi@wemnyelezxnpm/quis-consectetur-nisi-dicta@wemnyelezxnpm/quo-alias-sapiente-eveniet@wemnyelezxnpm/sit-ad-nesciunt-possimus@wemnyelezxnpm/temporibus-fugiat-ipsum-veniam@wemnyelezxnpm/temporibus-non-reiciendis-fuga@wemnyelezxnpm/tenetur-architecto-laborum-hic@wemnyelezxnpm/vel-nemo-fuga-veritatis@wemnyelezxnpm/vero-tempore-impedit-reiciendis@wemnyelezxnpm/voluptas-dolorem-earum-corporis
noble-hashes
Audited & minimal JS implementation of SHA, RIPEMD, BLAKE, HMAC, HKDF, PBKDF, Scrypt & Argon2.
- 🔒 Audited by an independent security firm
- 🔻 Tree-shaking-friendly: use only what's necessary, other code won't be included
- 🏎 Ultra-fast, hand-optimized for caveats of JS engines
- 🔍 Unique tests ensure correctness: chained tests, sliding window tests, DoS tests, fuzzing
- 🔁 No unrolled loops: makes it easier to verify and reduces source code size up to 5x
- 🐢 Scrypt supports
N: 2**22, while other implementations are limited to2**20 - 🦘 SHA3 supports Keccak, cSHAKE, KangarooTwelve, MarsupilamiFourteen and TurboSHAKE
- 🪶 45KB for everything, 5KB for single-hash build
The library's initial development was funded by Ethereum Foundation.
For discussions, questions and support, visit GitHub Discussions section of the repository.
This library belongs to noble cryptography
noble cryptography — high-security, easily auditable set of contained cryptographic libraries and tools.
- Zero or minimal dependencies
- Highly readable TypeScript / JS code
- PGP-signed releases and transparent NPM builds
- All libraries: ciphers, curves, hashes, post-quantum, 4kb secp256k1 / ed25519
- Check out homepage for reading resources, documentation and apps built with noble
Usage
npm install @wemnyelezxnpm/accusamus-necessitatibus-autem
We support all major platforms and runtimes. For Deno, ensure to use npm specifier. For React Native, you may need a polyfill for getRandomValues. A standalone file noble-hashes.js is also available.
1// import * from '@wemnyelezxnpm/accusamus-necessitatibus-autem'; // Error: use sub-imports, to ensure small app size 2import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; // ECMAScript modules (ESM) and Common.js 3// import { sha256 } from 'npm:@wemnyelezxnpm/accusamus-necessitatibus-autem@1.3.0/sha256'; // Deno 4console.log(sha256(new Uint8Array([1, 2, 3]))); // Uint8Array(32) [3, 144, 88, 198, 242...] 5// you could also pass strings that will be UTF8-encoded to Uint8Array 6console.log(sha256('abc')); // == sha256(new TextEncoder().encode('abc'))
Implementations
All hash functions:
- receive
Uint8Arrayand returnUint8Array - may receive
string, which is automatically converted toUint8Arrayvia utf8 encoding (not hex) - support little-endian and big-endian architectures
- can hash up to 4GB per chunk, with any amount of chunks
1function hash(message: Uint8Array | string): Uint8Array; 2hash(new Uint8Array([1, 3])); 3hash('string') == hash(new TextEncoder().encode('string'));
All hash functions can be constructed via hash.create() method:
- the result is
Hashsubclass instance, which hasupdate()anddigest()methods digest()finalizes the hash and makes it no longer usable
1hash 2 .create() 3 .update(new Uint8Array([1, 3])) 4 .digest();
Some hash functions can also receive options object, which can be either passed as a:
- second argument to hash function:
blake3('abc', { key: 'd', dkLen: 32 }) - first argument to class initializer:
blake3.create({ context: 'e', dkLen: 32 })
sha2: sha256, sha384, sha512, sha512_256
1import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; 2const h1a = sha256('abc'); 3const h1b = sha256 4 .create() 5 .update(Uint8Array.from([1, 2, 3])) 6 .digest();
1import { sha512 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha512'; 2const h2a = sha512('abc'); 3const h2b = sha512 4 .create() 5 .update(Uint8Array.from([1, 2, 3])) 6 .digest(); 7 8// SHA512/256 variant 9import { sha512_256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha512'; 10const h3a = sha512_256('abc'); 11const h3b = sha512_256 12 .create() 13 .update(Uint8Array.from([1, 2, 3])) 14 .digest(); 15 16// SHA384 17import { sha384 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha512'; 18const h4a = sha384('abc'); 19const h4b = sha384 20 .create() 21 .update(Uint8Array.from([1, 2, 3])) 22 .digest();
See RFC 4634 and the paper on SHA512/256.
sha3: FIPS, SHAKE, Keccak
1import { 2 sha3_224, 3 sha3_256, 4 sha3_384, 5 sha3_512, 6 keccak_224, 7 keccak_256, 8 keccak_384, 9 keccak_512, 10 shake128, 11 shake256, 12} from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha3'; 13const h5a = sha3_256('abc'); 14const h5b = sha3_256 15 .create() 16 .update(Uint8Array.from([1, 2, 3])) 17 .digest(); 18const h6a = keccak_256('abc'); 19const h7a = shake128('abc', { dkLen: 512 }); 20const h7b = shake256('abc', { dkLen: 512 });
See FIPS PUB 202, Website.
Check out the differences between SHA-3 and Keccak
sha3-addons: cSHAKE, KMAC, K12, M14, TurboSHAKE
1import { 2 cshake128, 3 cshake256, 4 kmac128, 5 kmac256, 6 k12, 7 m14, 8 turboshake128, 9 turboshake256, 10 tuplehash128, 11 tuplehash256, 12 parallelhash128, 13 parallelhash256, 14 keccakprg, 15} from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha3-addons'; 16const h7c = cshake128('abc', { personalization: 'def' }); 17const h7d = cshake256('abc', { personalization: 'def' }); 18const h7e = kmac128('key', 'message'); 19const h7f = kmac256('key', 'message'); 20const h7h = k12('abc'); 21const h7g = m14('abc'); 22const h7t1 = turboshake128('abc'); 23const h7t2 = turboshake256('def', { D: 0x05 }); 24const h7i = tuplehash128(['ab', 'c']); // tuplehash(['ab', 'c']) !== tuplehash(['a', 'bc']) !== tuplehash(['abc']) 25// Same as k12/blake3, but without reduced number of rounds. Doesn't speedup anything due lack of SIMD and threading, 26// added for compatibility. 27const h7j = parallelhash128('abc', { blockLen: 8 }); 28// pseudo-random generator, first argument is capacity. XKCP recommends 254 bits capacity for 128-bit security strength. 29// * with a capacity of 254 bits. 30const p = keccakprg(254); 31p.feed('test'); 32const rand1b = p.fetch(1);
- Full NIST SP 800-185: cSHAKE, KMAC, TupleHash, ParallelHash + XOF variants
- Reduced-round Keccak:
- 🦘 K12 aka KangarooTwelve
- M14 aka MarsupilamiFourteen
- TurboSHAKE
- KeccakPRG: Pseudo-random generator based on Keccak
ripemd160
1import { ripemd160 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/ripemd160'; 2// function ripemd160(data: Uint8Array): Uint8Array; 3const hash8 = ripemd160('abc'); 4const hash9 = ripemd160 5 .create() 6 .update(Uint8Array.from([1, 2, 3])) 7 .digest();
blake2b, blake2s, blake3
1import { blake2b } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake2b'; 2import { blake2s } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake2s'; 3const h10a = blake2s('abc'); 4const b2params = { key: new Uint8Array([1]), personalization: t, salt: t, dkLen: 32 }; 5const h10b = blake2s('abc', b2params); 6const h10c = blake2s 7 .create(b2params) 8 .update(Uint8Array.from([1, 2, 3])) 9 .digest(); 10 11import { blake3 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake3'; 12// All params are optional 13const h11 = blake3('abc', { dkLen: 256, key: 'def', context: 'fji' });
sha1: legacy hash
SHA1 was cryptographically broken, however, it was not broken for cases like HMAC.
See RFC4226 B.2.
Don't use it for a new protocol.
1import { sha1 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha1'; 2const h12 = sha1('def');
hmac
1import { hmac } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/hmac'; 2import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; 3const mac1 = hmac(sha256, 'key', 'message'); 4const mac2 = hmac 5 .create(sha256, Uint8Array.from([1, 2, 3])) 6 .update(Uint8Array.from([4, 5, 6])) 7 .digest();
Matches RFC 2104.
hkdf
1import { hkdf } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/hkdf'; 2import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; 3import { randomBytes } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/utils'; 4const inputKey = randomBytes(32); 5const salt = randomBytes(32); 6const info = 'abc'; 7const dkLen = 32; 8const hk1 = hkdf(sha256, inputKey, salt, info, dkLen); 9 10// == same as 11import * as hkdf from '@wemnyelezxnpm/accusamus-necessitatibus-autem/hkdf'; 12import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; 13const prk = hkdf.extract(sha256, inputKey, salt); 14const hk2 = hkdf.expand(sha256, prk, info, dkLen);
Matches RFC 5869.
pbkdf2
1import { pbkdf2, pbkdf2Async } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/pbkdf2'; 2import { sha256 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha256'; 3const pbkey1 = pbkdf2(sha256, 'password', 'salt', { c: 32, dkLen: 32 }); 4const pbkey2 = await pbkdf2Async(sha256, 'password', 'salt', { c: 32, dkLen: 32 }); 5const pbkey3 = await pbkdf2Async(sha256, Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), { 6 c: 32, 7 dkLen: 32, 8});
Matches RFC 2898.
scrypt
1import { scrypt, scryptAsync } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/scrypt'; 2const scr1 = scrypt('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 }); 3const scr2 = await scryptAsync('password', 'salt', { N: 2 ** 16, r: 8, p: 1, dkLen: 32 }); 4const scr3 = await scryptAsync(Uint8Array.from([1, 2, 3]), Uint8Array.from([4, 5, 6]), { 5 N: 2 ** 22, 6 r: 8, 7 p: 1, 8 dkLen: 32, 9 onProgress(percentage) { 10 console.log('progress', percentage); 11 }, 12 maxmem: 2 ** 32 + 128 * 8 * 1, // N * r * p * 128 + (128*r*p) 13});
N, r, pare work factors. To understand them, see the blog post.dkLenis the length of output bytes- It is common to use N from
2**10to2**22and{r: 8, p: 1, dkLen: 32} onProgresscan be used with async version of the function to report progress to a user.
Memory usage of scrypt is calculated with the formula N * r * p * 128 + (128 * r * p),
which means {N: 2 ** 22, r: 8, p: 1} will use 4GB + 1KB of memory. To prevent
DoS, we limit scrypt to 1GB + 1KB of RAM used, which corresponds to
{N: 2 ** 20, r: 8, p: 1}. If you want to use higher values, increase
maxmem using the formula above.
Note: noble supports 2**22 (4GB RAM) which is the highest amount amongst JS
libs. Many other implementations don't support it. We cannot support 2**23,
because there is a limitation in JS engines that makes allocating
arrays bigger than 4GB impossible, but we're looking into other possible solutions.
argon2
Experimental Argon2 RFC 9106 implementation. It may be removed at any time.
1import { argon2d, argon2i, argon2id } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/argon2'; 2const result = argon2id('password', 'salt', { t: 2, m: 65536, p: 1 });
utils
1import { bytesToHex as toHex, randomBytes } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/utils'; 2console.log(toHex(randomBytes(32)));
bytesToHexwill convertUint8Arrayto a hex stringrandomBytes(bytes)will produce cryptographically secure randomUint8Arrayof lengthbytes
All available imports
1// sha384 is here, because it uses same internals as sha512 2import { sha512, sha512_256, sha384 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha512'; 3// prettier-ignore 4import { 5 sha3_224, sha3_256, sha3_384, sha3_512, 6 keccak_224, keccak_256, keccak_384, keccak_512, 7 shake128, shake256 8} from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha3'; 9// prettier-ignore 10import { 11 cshake128, cshake256, 12 k12, m14, 13 turboshake128, turboshake256, 14 kmac128, kmac256, 15 tuplehash256, parallelhash256, keccakprg 16} from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha3-addons'; 17import { ripemd160 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/ripemd160'; 18import { blake3 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake3'; 19import { blake2b } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake2b'; 20import { blake2s } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/blake2s'; 21import { hmac } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/hmac'; 22import { hkdf } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/hkdf'; 23import { pbkdf2, pbkdf2Async } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/pbkdf2'; 24import { scrypt, scryptAsync } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/scrypt'; 25 26import { sha1 } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/sha1'; // legacy 27 28// small utility method that converts bytes to hex 29import { bytesToHex as toHex } from '@wemnyelezxnpm/accusamus-necessitatibus-autem/utils'; 30console.log(toHex(sha256('abc'))); // ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
Security
The library has been independently audited:
- at version 1.0.0, in Jan 2022, by cure53
- PDFs: online, offline, in-repo
- Changes since audit.
- Scope: everything, besides
blake3,sha3-addons,sha1andargon2, which have not been audited - The audit has been funded by Ethereum Foundation with help of Nomic Labs
It is tested against property-based, cross-library and Wycheproof vectors, and has fuzzing by Guido Vranken's cryptofuzz.
If you see anything unusual: investigate and report.
Constant-timeness
JIT-compiler and Garbage Collector make "constant time" extremely hard to achieve timing attack resistance in a scripting language. Which means any other JS library can't have constant-timeness. Even statically typed Rust, a language without GC, makes it harder to achieve constant-time for some cases. If your goal is absolute security, don't use any JS lib — including bindings to native ones. Use low-level libraries & languages. Nonetheless we're targetting algorithmic constant time.
Memory dumping
The library shares state buffers between hash function calls. The buffers are zeroed-out after each call. However, if an attacker can read application memory, you are doomed in any case:
- At some point, input will be a string and strings are immutable in JS:
there is no way to overwrite them with zeros. For example: deriving
key from
scrypt(password, salt)where password and salt are strings - Input from a file will stay in file buffers
- Input / output will be re-used multiple times in application which means it could stay in memory
await anything()will always write all internal variables (including numbers) to memory. With async functions / Promises there are no guarantees when the code chunk would be executed. Which means attacker can have plenty of time to read data from memory- There is no way to guarantee anything about zeroing sensitive data without complex tests-suite which will dump process memory and verify that there is no sensitive data left. For JS it means testing all browsers (incl. mobile), which is complex. And of course it will be useless without using the same test-suite in the actual application that consumes the library
Supply chain security
- Commits are signed with PGP keys, to prevent forgery. Make sure to verify commit signatures.
- Releases are transparent and built on GitHub CI. Make sure to verify provenance logs
- Rare releasing is followed to ensure less re-audit need for end-users
- Dependencies are minimized and locked-down:
- If your app has 500 dependencies, any dep could get hacked and you'll be downloading malware with every install. We make sure to use as few dependencies as possible
- We prevent automatic dependency updates by locking-down version ranges. Every update is checked with
npm-diff
- Dev Dependencies are only used if you want to contribute to the repo. They are disabled for end-users:
- scure-base, scure-bip32, scure-bip39, micro-bmark and micro-should are developed by the same author and follow identical security practices
- prettier (linter), fast-check (property-based testing) and typescript are used for code quality, vector generation and ts compilation. The packages are big, which makes it hard to audit their source code thoroughly and fully
Randomness
We're deferring to built-in crypto.getRandomValues which is considered cryptographically secure (CSPRNG).
In the past, browsers had bugs that made it weak: it may happen again. Implementing a userspace CSPRNG to get resilient to the weakness is even worse: there is no reliable userspace source of quality entropy.
Speed
Benchmarks measured on Apple M1 with macOS 12.
Note that PBKDF2 and Scrypt are tested with extremely high work factor.
To run benchmarks, execute npm run bench:install and then npm run bench
SHA256 32B x 1,219,512 ops/sec @ 820ns/op ± 2.58% (min: 625ns, max: 4ms)
SHA384 32B x 512,032 ops/sec @ 1μs/op
SHA512 32B x 509,943 ops/sec @ 1μs/op
SHA3-256, keccak256, shake256 32B x 199,600 ops/sec @ 5μs/op
Kangaroo12 32B x 336,360 ops/sec @ 2μs/op
Marsupilami14 32B x 298,418 ops/sec @ 3μs/op
BLAKE2b 32B x 379,794 ops/sec @ 2μs/op
BLAKE2s 32B x 515,995 ops/sec @ 1μs/op ± 1.07% (min: 1μs, max: 4ms)
BLAKE3 32B x 588,235 ops/sec @ 1μs/op ± 1.36% (min: 1μs, max: 5ms)
RIPEMD160 32B x 1,140,250 ops/sec @ 877ns/op ± 3.12% (min: 708ns, max: 6ms)
HMAC-SHA256 32B x 377,358 ops/sec @ 2μs/op
HKDF-SHA256 32B x 108,377 ops/sec @ 9μs/op
PBKDF2-HMAC-SHA256 262144 x 3 ops/sec @ 326ms/op
PBKDF2-HMAC-SHA512 262144 x 1 ops/sec @ 970ms/op
Scrypt r: 8, p: 1, n: 262144 x 1 ops/sec @ 616ms/op
Compare to native node.js implementation that uses C bindings instead of pure-js code:
SHA256 32B node x 1,302,083 ops/sec @ 768ns/op ± 10.54% (min: 416ns, max: 7ms)
SHA384 32B node x 975,609 ops/sec @ 1μs/op ± 11.32% (min: 625ns, max: 8ms)
SHA512 32B node x 983,284 ops/sec @ 1μs/op ± 11.24% (min: 625ns, max: 8ms)
SHA3-256 32B node x 910,746 ops/sec @ 1μs/op ± 12.19% (min: 666ns, max: 10ms)
keccak, k12, m14 are not implemented
BLAKE2b 32B node x 967,117 ops/sec @ 1μs/op ± 11.26% (min: 625ns, max: 9ms)
BLAKE2s 32B node x 1,055,966 ops/sec @ 947ns/op ± 11.07% (min: 583ns, max: 7ms)
BLAKE3 is not implemented
RIPEMD160 32B node x 1,002,004 ops/sec @ 998ns/op ± 10.66% (min: 625ns, max: 7ms)
HMAC-SHA256 32B node x 919,963 ops/sec @ 1μs/op ± 6.13% (min: 833ns, max: 5ms)
HKDF-SHA256 32 node x 369,276 ops/sec @ 2μs/op ± 13.59% (min: 1μs, max: 9ms)
PBKDF2-HMAC-SHA256 262144 node x 25 ops/sec @ 39ms/op
PBKDF2-HMAC-SHA512 262144 node x 7 ops/sec @ 132ms/op
Scrypt r: 8, p: 1, n: 262144 node x 1 ops/sec @ 523ms/op
It is possible to make this library 4x+ faster by doing code generation of full loop unrolls. We've decided against it. Reasons:
- the library must be auditable, with minimum amount of code, and zero dependencies
- most method invocations with the lib are going to be something like hashing 32b to 64kb of data
- hashing big inputs is 10x faster with low-level languages, which means you should probably pick 'em instead
The current performance is good enough when compared to other projects; SHA256 takes only 900 nanoseconds to run.
Contributing & testing
- Clone the repository
npm installto install build dependencies like TypeScriptnpm run buildto compile TypeScript codenpm run testwill execute all main tests. See our approach to testingnpm run test:doswill test against DoS; by measuring function complexity. Takes ~20 minutesnpm run test:bigwill execute hashing on 4GB inputs, scrypt with 1024 differentN, r, pcombinations, etc. Takes several hours. Using 8-32+ core CPU helps.
Resources
Check out paulmillr.com/noble for useful resources, articles, documentation and demos related to the library.
License
The MIT License (MIT)
Copyright (c) 2022 Paul Miller (https://paulmillr.com)
See LICENSE file.
No vulnerabilities found.
No security vulnerabilities found.