You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
377 lines
13 KiB
377 lines
13 KiB
"use strict";
|
|
/**
|
|
* Hex, bytes and number utilities.
|
|
* @module
|
|
*/
|
|
/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.notImplemented = exports.bitMask = void 0;
|
|
exports.isBytes = isBytes;
|
|
exports.abytes = abytes;
|
|
exports.abool = abool;
|
|
exports.numberToHexUnpadded = numberToHexUnpadded;
|
|
exports.hexToNumber = hexToNumber;
|
|
exports.bytesToHex = bytesToHex;
|
|
exports.hexToBytes = hexToBytes;
|
|
exports.bytesToNumberBE = bytesToNumberBE;
|
|
exports.bytesToNumberLE = bytesToNumberLE;
|
|
exports.numberToBytesBE = numberToBytesBE;
|
|
exports.numberToBytesLE = numberToBytesLE;
|
|
exports.numberToVarBytesBE = numberToVarBytesBE;
|
|
exports.ensureBytes = ensureBytes;
|
|
exports.concatBytes = concatBytes;
|
|
exports.equalBytes = equalBytes;
|
|
exports.utf8ToBytes = utf8ToBytes;
|
|
exports.inRange = inRange;
|
|
exports.aInRange = aInRange;
|
|
exports.bitLen = bitLen;
|
|
exports.bitGet = bitGet;
|
|
exports.bitSet = bitSet;
|
|
exports.createHmacDrbg = createHmacDrbg;
|
|
exports.validateObject = validateObject;
|
|
exports.memoized = memoized;
|
|
// 100 lines of code in the file are duplicated from noble-hashes (utils).
|
|
// This is OK: `abstract` directory does not use noble-hashes.
|
|
// User may opt-in into using different hashing library. This way, noble-hashes
|
|
// won't be included into their bundle.
|
|
const _0n = /* @__PURE__ */ BigInt(0);
|
|
const _1n = /* @__PURE__ */ BigInt(1);
|
|
function isBytes(a) {
|
|
return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
|
|
}
|
|
function abytes(item) {
|
|
if (!isBytes(item))
|
|
throw new Error('Uint8Array expected');
|
|
}
|
|
function abool(title, value) {
|
|
if (typeof value !== 'boolean')
|
|
throw new Error(title + ' boolean expected, got ' + value);
|
|
}
|
|
// Used in weierstrass, der
|
|
function numberToHexUnpadded(num) {
|
|
const hex = num.toString(16);
|
|
return hex.length & 1 ? '0' + hex : hex;
|
|
}
|
|
function hexToNumber(hex) {
|
|
if (typeof hex !== 'string')
|
|
throw new Error('hex string expected, got ' + typeof hex);
|
|
return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian
|
|
}
|
|
// Built-in hex conversion https://caniuse.com/mdn-javascript_builtins_uint8array_fromhex
|
|
const hasHexBuiltin =
|
|
// @ts-ignore
|
|
typeof Uint8Array.from([]).toHex === 'function' && typeof Uint8Array.fromHex === 'function';
|
|
// Array where index 0xf0 (240) is mapped to string 'f0'
|
|
const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
|
|
/**
|
|
* Convert byte array to hex string. Uses built-in function, when available.
|
|
* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
|
|
*/
|
|
function bytesToHex(bytes) {
|
|
abytes(bytes);
|
|
// @ts-ignore
|
|
if (hasHexBuiltin)
|
|
return bytes.toHex();
|
|
// 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(ch) {
|
|
if (ch >= asciis._0 && ch <= asciis._9)
|
|
return ch - asciis._0; // '2' => 50-48
|
|
if (ch >= asciis.A && ch <= asciis.F)
|
|
return ch - (asciis.A - 10); // 'B' => 66-(65-10)
|
|
if (ch >= asciis.a && ch <= asciis.f)
|
|
return ch - (asciis.a - 10); // 'b' => 98-(97-10)
|
|
return;
|
|
}
|
|
/**
|
|
* Convert hex string to byte array. Uses built-in function, when available.
|
|
* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
|
|
*/
|
|
function hexToBytes(hex) {
|
|
if (typeof hex !== 'string')
|
|
throw new Error('hex string expected, got ' + typeof hex);
|
|
// @ts-ignore
|
|
if (hasHexBuiltin)
|
|
return Uint8Array.fromHex(hex);
|
|
const hl = hex.length;
|
|
const al = hl / 2;
|
|
if (hl % 2)
|
|
throw new Error('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; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163
|
|
}
|
|
return array;
|
|
}
|
|
// BE: Big Endian, LE: Little Endian
|
|
function bytesToNumberBE(bytes) {
|
|
return hexToNumber(bytesToHex(bytes));
|
|
}
|
|
function bytesToNumberLE(bytes) {
|
|
abytes(bytes);
|
|
return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
|
|
}
|
|
function numberToBytesBE(n, len) {
|
|
return hexToBytes(n.toString(16).padStart(len * 2, '0'));
|
|
}
|
|
function numberToBytesLE(n, len) {
|
|
return numberToBytesBE(n, len).reverse();
|
|
}
|
|
// Unpadded, rarely used
|
|
function numberToVarBytesBE(n) {
|
|
return hexToBytes(numberToHexUnpadded(n));
|
|
}
|
|
/**
|
|
* Takes hex string or Uint8Array, converts to Uint8Array.
|
|
* Validates output length.
|
|
* Will throw error for other types.
|
|
* @param title descriptive title for an error e.g. 'private key'
|
|
* @param hex hex string or Uint8Array
|
|
* @param expectedLength optional, will compare to result array's length
|
|
* @returns
|
|
*/
|
|
function ensureBytes(title, hex, expectedLength) {
|
|
let res;
|
|
if (typeof hex === 'string') {
|
|
try {
|
|
res = hexToBytes(hex);
|
|
}
|
|
catch (e) {
|
|
throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);
|
|
}
|
|
}
|
|
else if (isBytes(hex)) {
|
|
// Uint8Array.from() instead of hash.slice() because node.js Buffer
|
|
// is instance of Uint8Array, and its slice() creates **mutable** copy
|
|
res = Uint8Array.from(hex);
|
|
}
|
|
else {
|
|
throw new Error(title + ' must be hex string or Uint8Array');
|
|
}
|
|
const len = res.length;
|
|
if (typeof expectedLength === 'number' && len !== expectedLength)
|
|
throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);
|
|
return res;
|
|
}
|
|
/**
|
|
* Copies several Uint8Arrays into one.
|
|
*/
|
|
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;
|
|
}
|
|
// Compares 2 u8a-s in kinda constant time
|
|
function equalBytes(a, b) {
|
|
if (a.length !== b.length)
|
|
return false;
|
|
let diff = 0;
|
|
for (let i = 0; i < a.length; i++)
|
|
diff |= a[i] ^ b[i];
|
|
return diff === 0;
|
|
}
|
|
/**
|
|
* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
|
|
*/
|
|
function utf8ToBytes(str) {
|
|
if (typeof str !== 'string')
|
|
throw new Error('string expected');
|
|
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
|
|
}
|
|
// Is positive bigint
|
|
const isPosBig = (n) => typeof n === 'bigint' && _0n <= n;
|
|
function inRange(n, min, max) {
|
|
return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
|
|
}
|
|
/**
|
|
* Asserts min <= n < max. NOTE: It's < max and not <= max.
|
|
* @example
|
|
* aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)
|
|
*/
|
|
function aInRange(title, n, min, max) {
|
|
// Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?
|
|
// consider P=256n, min=0n, max=P
|
|
// - a for min=0 would require -1: `inRange('x', x, -1n, P)`
|
|
// - b would commonly require subtraction: `inRange('x', x, 0n, P - 1n)`
|
|
// - our way is the cleanest: `inRange('x', x, 0n, P)
|
|
if (!inRange(n, min, max))
|
|
throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);
|
|
}
|
|
// Bit operations
|
|
/**
|
|
* Calculates amount of bits in a bigint.
|
|
* Same as `n.toString(2).length`
|
|
* TODO: merge with nLength in modular
|
|
*/
|
|
function bitLen(n) {
|
|
let len;
|
|
for (len = 0; n > _0n; n >>= _1n, len += 1)
|
|
;
|
|
return len;
|
|
}
|
|
/**
|
|
* Gets single bit at position.
|
|
* NOTE: first bit position is 0 (same as arrays)
|
|
* Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
|
|
*/
|
|
function bitGet(n, pos) {
|
|
return (n >> BigInt(pos)) & _1n;
|
|
}
|
|
/**
|
|
* Sets single bit at position.
|
|
*/
|
|
function bitSet(n, pos, value) {
|
|
return n | ((value ? _1n : _0n) << BigInt(pos));
|
|
}
|
|
/**
|
|
* Calculate mask for N bits. Not using ** operator with bigints because of old engines.
|
|
* Same as BigInt(`0b${Array(i).fill('1').join('')}`)
|
|
*/
|
|
const bitMask = (n) => (_1n << BigInt(n)) - _1n;
|
|
exports.bitMask = bitMask;
|
|
// DRBG
|
|
const u8n = (len) => new Uint8Array(len); // creates Uint8Array
|
|
const u8fr = (arr) => Uint8Array.from(arr); // another shortcut
|
|
/**
|
|
* Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
|
|
* @returns function that will call DRBG until 2nd arg returns something meaningful
|
|
* @example
|
|
* const drbg = createHmacDRBG<Key>(32, 32, hmac);
|
|
* drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
|
|
*/
|
|
function createHmacDrbg(hashLen, qByteLen, hmacFn) {
|
|
if (typeof hashLen !== 'number' || hashLen < 2)
|
|
throw new Error('hashLen must be a number');
|
|
if (typeof qByteLen !== 'number' || qByteLen < 2)
|
|
throw new Error('qByteLen must be a number');
|
|
if (typeof hmacFn !== 'function')
|
|
throw new Error('hmacFn must be a function');
|
|
// Step B, Step C: set hashLen to 8*ceil(hlen/8)
|
|
let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
|
|
let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same
|
|
let i = 0; // Iterations counter, will throw when over 1000
|
|
const reset = () => {
|
|
v.fill(1);
|
|
k.fill(0);
|
|
i = 0;
|
|
};
|
|
const h = (...b) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)
|
|
const reseed = (seed = u8n(0)) => {
|
|
// HMAC-DRBG reseed() function. Steps D-G
|
|
k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)
|
|
v = h(); // v = hmac(k || v)
|
|
if (seed.length === 0)
|
|
return;
|
|
k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)
|
|
v = h(); // v = hmac(k || v)
|
|
};
|
|
const gen = () => {
|
|
// HMAC-DRBG generate() function
|
|
if (i++ >= 1000)
|
|
throw new Error('drbg: tried 1000 values');
|
|
let len = 0;
|
|
const out = [];
|
|
while (len < qByteLen) {
|
|
v = h();
|
|
const sl = v.slice();
|
|
out.push(sl);
|
|
len += v.length;
|
|
}
|
|
return concatBytes(...out);
|
|
};
|
|
const genUntil = (seed, pred) => {
|
|
reset();
|
|
reseed(seed); // Steps D-G
|
|
let res = undefined; // Step H: grind until k is in [1..n-1]
|
|
while (!(res = pred(gen())))
|
|
reseed();
|
|
reset();
|
|
return res;
|
|
};
|
|
return genUntil;
|
|
}
|
|
// Validating curves and fields
|
|
const validatorFns = {
|
|
bigint: (val) => typeof val === 'bigint',
|
|
function: (val) => typeof val === 'function',
|
|
boolean: (val) => typeof val === 'boolean',
|
|
string: (val) => typeof val === 'string',
|
|
stringOrUint8Array: (val) => typeof val === 'string' || isBytes(val),
|
|
isSafeInteger: (val) => Number.isSafeInteger(val),
|
|
array: (val) => Array.isArray(val),
|
|
field: (val, object) => object.Fp.isValid(val),
|
|
hash: (val) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),
|
|
};
|
|
// type Record<K extends string | number | symbol, T> = { [P in K]: T; }
|
|
function validateObject(object, validators, optValidators = {}) {
|
|
const checkField = (fieldName, type, isOptional) => {
|
|
const checkVal = validatorFns[type];
|
|
if (typeof checkVal !== 'function')
|
|
throw new Error('invalid validator function');
|
|
const val = object[fieldName];
|
|
if (isOptional && val === undefined)
|
|
return;
|
|
if (!checkVal(val, object)) {
|
|
throw new Error('param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val);
|
|
}
|
|
};
|
|
for (const [fieldName, type] of Object.entries(validators))
|
|
checkField(fieldName, type, false);
|
|
for (const [fieldName, type] of Object.entries(optValidators))
|
|
checkField(fieldName, type, true);
|
|
return object;
|
|
}
|
|
// validate type tests
|
|
// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };
|
|
// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!
|
|
// // Should fail type-check
|
|
// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });
|
|
// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });
|
|
// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });
|
|
// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });
|
|
/**
|
|
* throws not implemented error
|
|
*/
|
|
const notImplemented = () => {
|
|
throw new Error('not implemented');
|
|
};
|
|
exports.notImplemented = notImplemented;
|
|
/**
|
|
* Memoizes (caches) computation result.
|
|
* Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.
|
|
*/
|
|
function memoized(fn) {
|
|
const map = new WeakMap();
|
|
return (arg, ...args) => {
|
|
const val = map.get(arg);
|
|
if (val !== undefined)
|
|
return val;
|
|
const computed = fn(arg, ...args);
|
|
map.set(arg, computed);
|
|
return computed;
|
|
};
|
|
}
|
|
//# sourceMappingURL=utils.js.map
|