js-randomness-predictor
Version:
Predict Math.random output in Node, Chrome, and Firefox
191 lines (190 loc) • 13.4 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
if (kind === "m") throw new TypeError("Private method is not writable");
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _V8RandomnessPredictor_instances, _V8RandomnessPredictor_nodeVersion, _V8RandomnessPredictor_isInitialized, _V8RandomnessPredictor_concreteState0, _V8RandomnessPredictor_concreteState1, _V8RandomnessPredictor_mask, _V8RandomnessPredictor_internalSequence, _V8RandomnessPredictor_seState0, _V8RandomnessPredictor_seState1, _V8RandomnessPredictor_s0Ref, _V8RandomnessPredictor_s1Ref, _V8RandomnessPredictor_solver, _V8RandomnessPredictor_context, _V8RandomnessPredictor_getNodeVersion, _V8RandomnessPredictor_initialize, _V8RandomnessPredictor_xorShift128PlusSymbolic, _V8RandomnessPredictor_xorShift128PlusConcrete, _V8RandomnessPredictor_recoverMantissaAndAddToSolver, _V8RandomnessPredictor_toDouble;
Object.defineProperty(exports, "__esModule", { value: true });
const z3 = __importStar(require("z3-solver"));
/**
*
* 1. In Node v24.x.x (commit was in Feb2025), V8 updated their impl of the `ToDouble` method. The old method was in use since 2022.
* This caused breaking changes to this predictor, so we now have to detect node version so we can choose which ToDouble to implement.
* - Old Impl: https://github.com/v8/v8/blob/e99218a1cca470ddec1931547b36a256f3450078/src/base/utils/random-number-generator.h#L111
* ```
* // Static and exposed for external use.
* static inline double ToDouble(uint64_t state0) {
* // Exponent for double values for [1.0 .. 2.0)
* static const uint64_t kExponentBits = uint64_t{0x3FF0000000000000};
* uint64_t random = (state0 >> 12) | kExponentBits;
* return base::bit_cast<double>(random) - 1;
* }
* ```
* - New Impl: https://github.com/v8/v8/blob/1c3a9c08e932e87b04c7bf9ecc648e1f50d418fd/src/base/utils/random-number-generator.h#L111
* ```
* // Static and exposed for external use.
* static inline double ToDouble(uint64_t state0) {
* // Get a random [0,2**53) integer value (up to MAX_SAFE_INTEGER) by dropping
* // 11 bits of the state.
* double random_0_to_2_53 = static_cast<double>(state0 >> 11);
* // Map this to [0,1) by division with 2**53.
* constexpr double k2_53{static_cast<uint64_t>(1) << 53};
* return random_0_to_2_53 / k2_53;
* }
* ```
*
*/
class V8RandomnessPredictor {
constructor(sequence) {
_V8RandomnessPredictor_instances.add(this);
_V8RandomnessPredictor_nodeVersion.set(this, __classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_getNodeVersion).call(this));
_V8RandomnessPredictor_isInitialized.set(this, false);
_V8RandomnessPredictor_concreteState0.set(this, 0n);
_V8RandomnessPredictor_concreteState1.set(this, 0n);
_V8RandomnessPredictor_mask.set(this, 0xffffffffffffffffn);
_V8RandomnessPredictor_internalSequence.set(this, []);
_V8RandomnessPredictor_seState0.set(this, void 0);
_V8RandomnessPredictor_seState1.set(this, void 0);
_V8RandomnessPredictor_s0Ref.set(this, void 0);
_V8RandomnessPredictor_s1Ref.set(this, void 0);
_V8RandomnessPredictor_solver.set(this, void 0);
_V8RandomnessPredictor_context.set(this, void 0);
if (sequence === undefined) {
sequence = Array.from({ length: 4 }, Math.random);
}
this.sequence = sequence;
__classPrivateFieldSet(this, _V8RandomnessPredictor_internalSequence, [...sequence.reverse()], "f");
}
async predictNext() {
await __classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_initialize).call(this);
return __classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_toDouble).call(this, __classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_xorShift128PlusConcrete).call(this));
}
// For testing - DO NOT USE IF YOU DON'T WANT TO BREAK THINGS.
setNodeVersion(version) {
__classPrivateFieldSet(this, _V8RandomnessPredictor_nodeVersion, version, "f");
}
}
_V8RandomnessPredictor_nodeVersion = new WeakMap(), _V8RandomnessPredictor_isInitialized = new WeakMap(), _V8RandomnessPredictor_concreteState0 = new WeakMap(), _V8RandomnessPredictor_concreteState1 = new WeakMap(), _V8RandomnessPredictor_mask = new WeakMap(), _V8RandomnessPredictor_internalSequence = new WeakMap(), _V8RandomnessPredictor_seState0 = new WeakMap(), _V8RandomnessPredictor_seState1 = new WeakMap(), _V8RandomnessPredictor_s0Ref = new WeakMap(), _V8RandomnessPredictor_s1Ref = new WeakMap(), _V8RandomnessPredictor_solver = new WeakMap(), _V8RandomnessPredictor_context = new WeakMap(), _V8RandomnessPredictor_instances = new WeakSet(), _V8RandomnessPredictor_getNodeVersion = function _V8RandomnessPredictor_getNodeVersion() {
const [major, minor, patch] = process.versions.node.split(".").map(Number);
return { major, minor, patch };
}, _V8RandomnessPredictor_initialize =
// `#initialize()` essentially solves symbolic state so we can move forward using
// concrete state (which is way faster than having to recompute symbolic state
// for every prediction).
async function _V8RandomnessPredictor_initialize() {
if (__classPrivateFieldGet(this, _V8RandomnessPredictor_isInitialized, "f")) {
return true;
}
try {
const { Context } = await z3.init();
__classPrivateFieldSet(this, _V8RandomnessPredictor_context, Context("main"), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_solver, new (__classPrivateFieldGet(this, _V8RandomnessPredictor_context, "f").Solver)(), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_seState0, __classPrivateFieldGet(this, _V8RandomnessPredictor_context, "f").BitVec.const("se_state0", 64), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_seState1, __classPrivateFieldGet(this, _V8RandomnessPredictor_context, "f").BitVec.const("se_state1", 64), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_s0Ref, __classPrivateFieldGet(this, _V8RandomnessPredictor_seState0, "f"), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_s1Ref, __classPrivateFieldGet(this, _V8RandomnessPredictor_seState1, "f"), "f");
for (let i = 0; i < __classPrivateFieldGet(this, _V8RandomnessPredictor_internalSequence, "f").length; i++) {
__classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_xorShift128PlusSymbolic).call(this);
__classPrivateFieldGet(this, _V8RandomnessPredictor_instances, "m", _V8RandomnessPredictor_recoverMantissaAndAddToSolver).call(this, __classPrivateFieldGet(this, _V8RandomnessPredictor_internalSequence, "f")[i]);
}
const check = await __classPrivateFieldGet(this, _V8RandomnessPredictor_solver, "f").check();
if (check !== "sat") {
return Promise.reject(new Error(`[V8] Unsatisfiable: unable to reconstruct internal state. ${check}`));
}
const model = __classPrivateFieldGet(this, _V8RandomnessPredictor_solver, "f").model();
__classPrivateFieldSet(this, _V8RandomnessPredictor_concreteState0, model.get(__classPrivateFieldGet(this, _V8RandomnessPredictor_s0Ref, "f")).value(), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_concreteState1, model.get(__classPrivateFieldGet(this, _V8RandomnessPredictor_s1Ref, "f")).value(), "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_isInitialized, true, "f");
return true;
}
catch (e) {
return Promise.reject(e);
}
}, _V8RandomnessPredictor_xorShift128PlusSymbolic = function _V8RandomnessPredictor_xorShift128PlusSymbolic() {
if (!__classPrivateFieldGet(this, _V8RandomnessPredictor_seState0, "f") || !__classPrivateFieldGet(this, _V8RandomnessPredictor_seState1, "f")) {
throw new Error(`[V8][xorShift128PlusSymbolic] Either seState0 or seState1 is undefined!`);
}
let s1 = __classPrivateFieldGet(this, _V8RandomnessPredictor_seState0, "f");
let s0 = __classPrivateFieldGet(this, _V8RandomnessPredictor_seState1, "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_seState0, s0, "f");
s1 = s1.xor(s1.shl(23));
s1 = s1.xor(s1.lshr(17));
s1 = s1.xor(s0);
s1 = s1.xor(s0.lshr(26));
__classPrivateFieldSet(this, _V8RandomnessPredictor_seState1, s1, "f");
}, _V8RandomnessPredictor_xorShift128PlusConcrete = function _V8RandomnessPredictor_xorShift128PlusConcrete() {
const result = __classPrivateFieldGet(this, _V8RandomnessPredictor_concreteState0, "f");
let ps1 = __classPrivateFieldGet(this, _V8RandomnessPredictor_concreteState0, "f");
let ps0 = __classPrivateFieldGet(this, _V8RandomnessPredictor_concreteState1, "f") ^ (ps1 >> 26n);
ps0 ^= ps1;
ps0 = (ps0 ^ (ps0 >> 17n) ^ (ps0 >> 34n) ^ (ps0 >> 51n)) & __classPrivateFieldGet(this, _V8RandomnessPredictor_mask, "f");
ps0 = (ps0 ^ (ps0 << 23n) ^ (ps0 << 46n)) & __classPrivateFieldGet(this, _V8RandomnessPredictor_mask, "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_concreteState0, ps0, "f");
__classPrivateFieldSet(this, _V8RandomnessPredictor_concreteState1, ps1, "f");
return result;
}, _V8RandomnessPredictor_recoverMantissaAndAddToSolver = function _V8RandomnessPredictor_recoverMantissaAndAddToSolver(n) {
const majorVersion = __classPrivateFieldGet(this, _V8RandomnessPredictor_nodeVersion, "f").major;
if (majorVersion >= 24) {
// New `ToDouble` logic (Feb 2025) introduced to V8.
const mantissa = Math.floor(n * Math.pow(2, 53));
__classPrivateFieldGet(this, _V8RandomnessPredictor_solver, "f").add(__classPrivateFieldGet(this, _V8RandomnessPredictor_seState0, "f").lshr(11).eq(__classPrivateFieldGet(this, _V8RandomnessPredictor_context, "f").BitVec.val(BigInt(mantissa), 64)));
return;
}
// Old `ToDouble` logic (in use from ~2022 - Feb 2025)
const buffer = Buffer.alloc(8);
buffer.writeDoubleLE(n + 1, 0);
const uint64 = (BigInt(buffer.readUInt32LE(4)) << 32n) | BigInt(buffer.readUInt32LE(0));
const mantissa = uint64 & ((1n << 52n) - 1n);
__classPrivateFieldGet(this, _V8RandomnessPredictor_solver, "f").add(__classPrivateFieldGet(this, _V8RandomnessPredictor_seState0, "f").lshr(12).eq(__classPrivateFieldGet(this, _V8RandomnessPredictor_context, "f").BitVec.val(mantissa, 64)));
}, _V8RandomnessPredictor_toDouble = function _V8RandomnessPredictor_toDouble(n) {
const majorVersion = __classPrivateFieldGet(this, _V8RandomnessPredictor_nodeVersion, "f").major;
if (majorVersion >= 24) {
/* New ToDouble logic (Feb 2025+) */
return Number(n >> 11n) / Math.pow(2, 53);
}
/* Old logic (pre-Feb 2025) */
const buffer = Buffer.allocUnsafe(8);
buffer.writeBigUInt64LE((n >> 12n) | 0x3ff0000000000000n, 0);
return buffer.readDoubleLE(0) - 1;
};
exports.default = V8RandomnessPredictor;