206 lines
7.4 KiB
JavaScript
206 lines
7.4 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.u64Lengths = exports.setBigUint64 = exports.wrapCipher = exports.Hash = exports.equalBytes = exports.checkOpts = exports.concatBytes = exports.toBytes = exports.bytesToUtf8 = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.numberToBytesBE = exports.bytesToNumberBE = exports.hexToNumber = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.createView = exports.u32 = exports.u16 = exports.u8 = void 0;
|
|
/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
|
|
const _assert_js_1 = require("./_assert.js");
|
|
// Cast array to different type
|
|
const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
exports.u8 = u8;
|
|
const u16 = (arr) => new Uint16Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 2));
|
|
exports.u16 = u16;
|
|
const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
|
|
exports.u32 = u32;
|
|
// Cast array to view
|
|
const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
|
|
exports.createView = createView;
|
|
// big-endian hardware is rare. Just in case someone still decides to run ciphers:
|
|
// early-throw an error because we don't support BE yet.
|
|
exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
|
|
if (!exports.isLE)
|
|
throw new Error('Non little-endian hardware is not supported');
|
|
// 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'
|
|
*/
|
|
function bytesToHex(bytes) {
|
|
(0, _assert_js_1.bytes)(bytes);
|
|
// pre-caching improves the speed 6x
|
|
let hex = '';
|
|
for (let i = 0; i < bytes.length; i++) {
|
|
hex += hexes[bytes[i]];
|
|
}
|
|
return hex;
|
|
}
|
|
exports.bytesToHex = bytesToHex;
|
|
// 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])
|
|
*/
|
|
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;
|
|
}
|
|
exports.hexToBytes = hexToBytes;
|
|
function hexToNumber(hex) {
|
|
if (typeof hex !== 'string')
|
|
throw new Error('hex string expected, got ' + typeof hex);
|
|
// Big Endian
|
|
return BigInt(hex === '' ? '0' : `0x${hex}`);
|
|
}
|
|
exports.hexToNumber = hexToNumber;
|
|
// BE: Big Endian, LE: Little Endian
|
|
function bytesToNumberBE(bytes) {
|
|
return hexToNumber(bytesToHex(bytes));
|
|
}
|
|
exports.bytesToNumberBE = bytesToNumberBE;
|
|
function numberToBytesBE(n, len) {
|
|
return hexToBytes(n.toString(16).padStart(len * 2, '0'));
|
|
}
|
|
exports.numberToBytesBE = numberToBytesBE;
|
|
// 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.
|
|
const nextTick = async () => { };
|
|
exports.nextTick = nextTick;
|
|
// Returns control to thread each 'tick' ms to avoid blocking
|
|
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 (0, exports.nextTick)();
|
|
ts += diff;
|
|
}
|
|
}
|
|
exports.asyncLoop = asyncLoop;
|
|
/**
|
|
* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
|
|
*/
|
|
function utf8ToBytes(str) {
|
|
if (typeof str !== 'string')
|
|
throw new Error(`string expected, got ${typeof str}`);
|
|
return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
|
|
}
|
|
exports.utf8ToBytes = utf8ToBytes;
|
|
/**
|
|
* @example bytesToUtf8(new Uint8Array([97, 98, 99])) // 'abc'
|
|
*/
|
|
function bytesToUtf8(bytes) {
|
|
return new TextDecoder().decode(bytes);
|
|
}
|
|
exports.bytesToUtf8 = bytesToUtf8;
|
|
/**
|
|
* 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.
|
|
*/
|
|
function toBytes(data) {
|
|
if (typeof data === 'string')
|
|
data = utf8ToBytes(data);
|
|
else if ((0, _assert_js_1.isBytes)(data))
|
|
data = data.slice();
|
|
else
|
|
throw new Error(`Uint8Array expected, got ${typeof data}`);
|
|
return data;
|
|
}
|
|
exports.toBytes = toBytes;
|
|
/**
|
|
* Copies several Uint8Arrays into one.
|
|
*/
|
|
function concatBytes(...arrays) {
|
|
let sum = 0;
|
|
for (let i = 0; i < arrays.length; i++) {
|
|
const a = arrays[i];
|
|
(0, _assert_js_1.bytes)(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;
|
|
}
|
|
exports.concatBytes = concatBytes;
|
|
function checkOpts(defaults, opts) {
|
|
if (opts == null || typeof opts !== 'object')
|
|
throw new Error('options must be defined');
|
|
const merged = Object.assign(defaults, opts);
|
|
return merged;
|
|
}
|
|
exports.checkOpts = checkOpts;
|
|
// 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;
|
|
}
|
|
exports.equalBytes = equalBytes;
|
|
// For runtime check if class implements interface
|
|
class Hash {
|
|
}
|
|
exports.Hash = Hash;
|
|
/**
|
|
* @__NO_SIDE_EFFECTS__
|
|
*/
|
|
const wrapCipher = (params, c) => {
|
|
Object.assign(c, params);
|
|
return c;
|
|
};
|
|
exports.wrapCipher = wrapCipher;
|
|
// Polyfill for Safari 14
|
|
function setBigUint64(view, byteOffset, value, isLE) {
|
|
if (typeof view.setBigUint64 === 'function')
|
|
return view.setBigUint64(byteOffset, value, isLE);
|
|
const _32n = BigInt(32);
|
|
const _u32_max = BigInt(0xffffffff);
|
|
const wh = Number((value >> _32n) & _u32_max);
|
|
const wl = Number(value & _u32_max);
|
|
const h = isLE ? 4 : 0;
|
|
const l = isLE ? 0 : 4;
|
|
view.setUint32(byteOffset + h, wh, isLE);
|
|
view.setUint32(byteOffset + l, wl, isLE);
|
|
}
|
|
exports.setBigUint64 = setBigUint64;
|
|
function u64Lengths(ciphertext, AAD) {
|
|
const num = new Uint8Array(16);
|
|
const view = (0, exports.createView)(num);
|
|
setBigUint64(view, 0, BigInt(AAD ? AAD.length : 0), true);
|
|
setBigUint64(view, 8, BigInt(ciphertext.length), true);
|
|
return num;
|
|
}
|
|
exports.u64Lengths = u64Lengths;
|
|
//# sourceMappingURL=utils.js.map
|