188 lines
7.1 KiB
JavaScript
188 lines
7.1 KiB
JavaScript
/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
|
// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
|
|
// node.js versions earlier than v19 don't declare it in global scope.
|
|
// For node.js, package.json#exports field mapping rewrites import
|
|
// from `crypto` to `cryptoNode`, which imports native module.
|
|
// Makes the utils un-importable in browsers without a bundler.
|
|
// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
|
|
import { crypto } from './crypto.js';
|
|
import { bytes as abytes } from './_assert.js';
|
|
// export { isBytes } from './_assert.js';
|
|
// We can't reuse isBytes from _assert, because somehow this causes huge perf issues
|
|
export function isBytes(a) {
|
|
return (a instanceof Uint8Array ||
|
|
(a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
|
|
}
|
|
// Cast array to different type
|
|
export const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
export const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
|
|
// Cast array to view
|
|
export const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
// The rotate right (circular right shift) operation for uint32
|
|
export const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
|
|
// The rotate left (circular left shift) operation for uint32
|
|
export const rotl = (word, shift) => (word << shift) | ((word >>> (32 - shift)) >>> 0);
|
|
export const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
|
|
// The byte swap operation for uint32
|
|
export const byteSwap = (word) => ((word << 24) & 0xff000000) |
|
|
((word << 8) & 0xff0000) |
|
|
((word >>> 8) & 0xff00) |
|
|
((word >>> 24) & 0xff);
|
|
// Conditionally byte swap if on a big-endian platform
|
|
export const byteSwapIfBE = isLE ? (n) => n : (n) => byteSwap(n);
|
|
// In place byte swap for Uint32Array
|
|
export function byteSwap32(arr) {
|
|
for (let i = 0; i < arr.length; i++) {
|
|
arr[i] = byteSwap(arr[i]);
|
|
}
|
|
}
|
|
// Array where index 0xf0 (240) is mapped to string 'f0'
|
|
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
|
|
/**
|
|
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
|
|
*/
|
|
export function bytesToHex(bytes) {
|
|
abytes(bytes);
|
|
// pre-caching improves the speed 6x
|
|
let hex = '';
|
|
for (let i = 0; i < bytes.length; i++) {
|
|
hex += hexes[bytes[i]];
|
|
}
|
|
return hex;
|
|
}
|
|
// We use optimized technique to convert hex string to byte array
|
|
const asciis = { _0: 48, _9: 57, _A: 65, _F: 70, _a: 97, _f: 102 };
|
|
function asciiToBase16(char) {
|
|
if (char >= asciis._0 && char <= asciis._9)
|
|
return char - asciis._0;
|
|
if (char >= asciis._A && char <= asciis._F)
|
|
return char - (asciis._A - 10);
|
|
if (char >= asciis._a && char <= asciis._f)
|
|
return char - (asciis._a - 10);
|
|
return;
|
|
}
|
|
/**
|
|
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
|
|
*/
|
|
export function hexToBytes(hex) {
|
|
if (typeof hex !== 'string')
|
|
throw new Error('hex string expected, got ' + typeof hex);
|
|
const hl = hex.length;
|
|
const al = hl / 2;
|
|
if (hl % 2)
|
|
throw new Error('padded hex string expected, got unpadded hex of length ' + hl);
|
|
const array = new Uint8Array(al);
|
|
for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
|
|
const n1 = asciiToBase16(hex.charCodeAt(hi));
|
|
const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
|
|
if (n1 === undefined || n2 === undefined) {
|
|
const char = hex[hi] + hex[hi + 1];
|
|
throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
|
|
}
|
|
array[ai] = n1 * 16 + n2;
|
|
}
|
|
return array;
|
|
}
|
|
// There is no setImmediate in browser and setTimeout is slow.
|
|
// call of async fn will return Promise, which will be fullfiled only on
|
|
// next scheduler queue processing step and this is exactly what we need.
|
|
export const nextTick = async () => { };
|
|
// Returns control to thread each 'tick' ms to avoid blocking
|
|
export async function asyncLoop(iters, tick, cb) {
|
|
let ts = Date.now();
|
|
for (let i = 0; i < iters; i++) {
|
|
cb(i);
|
|
// Date.now() is not monotonic, so in case if clock goes backwards we return return control too
|
|
const diff = Date.now() - ts;
|
|
if (diff >= 0 && diff < tick)
|
|
continue;
|
|
await nextTick();
|
|
ts += diff;
|
|
}
|
|
}
|
|
/**
|
|
* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
|
|
*/
|
|
export function utf8ToBytes(str) {
|
|
if (typeof str !== 'string')
|
|
throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
|
|
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
|
|
}
|
|
/**
|
|
* Normalizes (non-hex) string or Uint8Array to Uint8Array.
|
|
* Warning: when Uint8Array is passed, it would NOT get copied.
|
|
* Keep in mind for future mutable operations.
|
|
*/
|
|
export function toBytes(data) {
|
|
if (typeof data === 'string')
|
|
data = utf8ToBytes(data);
|
|
abytes(data);
|
|
return data;
|
|
}
|
|
/**
|
|
* Copies several Uint8Arrays into one.
|
|
*/
|
|
export function concatBytes(...arrays) {
|
|
let sum = 0;
|
|
for (let i = 0; i < arrays.length; i++) {
|
|
const a = arrays[i];
|
|
abytes(a);
|
|
sum += a.length;
|
|
}
|
|
const res = new Uint8Array(sum);
|
|
for (let i = 0, pad = 0; i < arrays.length; i++) {
|
|
const a = arrays[i];
|
|
res.set(a, pad);
|
|
pad += a.length;
|
|
}
|
|
return res;
|
|
}
|
|
// For runtime check if class implements interface
|
|
export class Hash {
|
|
// Safe version that clones internal state
|
|
clone() {
|
|
return this._cloneInto();
|
|
}
|
|
}
|
|
const toStr = {}.toString;
|
|
export function checkOpts(defaults, opts) {
|
|
if (opts !== undefined && toStr.call(opts) !== '[object Object]')
|
|
throw new Error('Options should be object or undefined');
|
|
const merged = Object.assign(defaults, opts);
|
|
return merged;
|
|
}
|
|
export function wrapConstructor(hashCons) {
|
|
const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
|
|
const tmp = hashCons();
|
|
hashC.outputLen = tmp.outputLen;
|
|
hashC.blockLen = tmp.blockLen;
|
|
hashC.create = () => hashCons();
|
|
return hashC;
|
|
}
|
|
export function wrapConstructorWithOpts(hashCons) {
|
|
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
|
|
const tmp = hashCons({});
|
|
hashC.outputLen = tmp.outputLen;
|
|
hashC.blockLen = tmp.blockLen;
|
|
hashC.create = (opts) => hashCons(opts);
|
|
return hashC;
|
|
}
|
|
export function wrapXOFConstructorWithOpts(hashCons) {
|
|
const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
|
|
const tmp = hashCons({});
|
|
hashC.outputLen = tmp.outputLen;
|
|
hashC.blockLen = tmp.blockLen;
|
|
hashC.create = (opts) => hashCons(opts);
|
|
return hashC;
|
|
}
|
|
/**
|
|
* Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
|
|
*/
|
|
export function randomBytes(bytesLength = 32) {
|
|
if (crypto && typeof crypto.getRandomValues === 'function') {
|
|
return crypto.getRandomValues(new Uint8Array(bytesLength));
|
|
}
|
|
throw new Error('crypto.getRandomValues must be defined');
|
|
}
|
|
//# sourceMappingURL=utils.js.map
|