mirror of
https://github.com/Ysurac/openmptcprouter-feeds.git
synced 2025-02-12 18:41:51 +00:00
402 lines
14 KiB
JavaScript
402 lines
14 KiB
JavaScript
/**
|
|
|
|
seedrandom.js
|
|
=============
|
|
|
|
Seeded random number generator for Javascript.
|
|
|
|
version 2.3.10
|
|
Author: David Bau
|
|
Date: 2014 Sep 20
|
|
|
|
Can be used as a plain script, a node.js module or an AMD module.
|
|
|
|
Script tag usage
|
|
----------------
|
|
|
|
<script src=//cdnjs.cloudflare.com/ajax/libs/seedrandom/2.3.10/seedrandom.min.js>
|
|
</script>
|
|
|
|
// Sets Math.random to a PRNG initialized using the given explicit seed.
|
|
Math.seedrandom('hello.');
|
|
console.log(Math.random()); // Always 0.9282578795792454
|
|
console.log(Math.random()); // Always 0.3752569768646784
|
|
|
|
// Sets Math.random to an ARC4-based PRNG that is autoseeded using the
|
|
// current time, dom state, and other accumulated local entropy.
|
|
// The generated seed string is returned.
|
|
Math.seedrandom();
|
|
console.log(Math.random()); // Reasonably unpredictable.
|
|
|
|
// Seeds using the given explicit seed mixed with accumulated entropy.
|
|
Math.seedrandom('added entropy.', { entropy: true });
|
|
console.log(Math.random()); // As unpredictable as added entropy.
|
|
|
|
// Use "new" to create a local prng without altering Math.random.
|
|
var myrng = new Math.seedrandom('hello.');
|
|
console.log(myrng()); // Always 0.9282578795792454
|
|
|
|
|
|
Node.js usage
|
|
-------------
|
|
|
|
npm install seedrandom
|
|
|
|
// Local PRNG: does not affect Math.random.
|
|
var seedrandom = require('seedrandom');
|
|
var rng = seedrandom('hello.');
|
|
console.log(rng()); // Always 0.9282578795792454
|
|
|
|
// Autoseeded ARC4-based PRNG.
|
|
rng = seedrandom();
|
|
console.log(rng()); // Reasonably unpredictable.
|
|
|
|
// Global PRNG: set Math.random.
|
|
seedrandom('hello.', { global: true });
|
|
console.log(Math.random()); // Always 0.9282578795792454
|
|
|
|
// Mixing accumulated entropy.
|
|
rng = seedrandom('added entropy.', { entropy: true });
|
|
console.log(rng()); // As unpredictable as added entropy.
|
|
|
|
|
|
Require.js usage
|
|
----------------
|
|
|
|
Similar to node.js usage:
|
|
|
|
bower install seedrandom
|
|
|
|
require(['seedrandom'], function(seedrandom) {
|
|
var rng = seedrandom('hello.');
|
|
console.log(rng()); // Always 0.9282578795792454
|
|
});
|
|
|
|
|
|
Network seeding
|
|
---------------
|
|
|
|
<script src=//cdnjs.cloudflare.com/ajax/libs/seedrandom/2.3.10/seedrandom.min.js>
|
|
</script>
|
|
|
|
<!-- Seeds using urandom bits from a server. -->
|
|
<script src=//jsonlib.appspot.com/urandom?callback=Math.seedrandom">
|
|
</script>
|
|
|
|
<!-- Seeds mixing in random.org bits -->
|
|
<script>
|
|
(function(x, u, s){
|
|
try {
|
|
// Make a synchronous request to random.org.
|
|
x.open('GET', u, false);
|
|
x.send();
|
|
s = unescape(x.response.trim().replace(/^|\s/g, '%'));
|
|
} finally {
|
|
// Seed with the response, or autoseed on failure.
|
|
Math.seedrandom(s, !!s);
|
|
}
|
|
})(new XMLHttpRequest, 'https://www.random.org/integers/' +
|
|
'?num=256&min=0&max=255&col=1&base=16&format=plain&rnd=new');
|
|
</script>
|
|
|
|
Reseeding using user input
|
|
--------------------------
|
|
|
|
var seed = Math.seedrandom(); // Use prng with an automatic seed.
|
|
document.write(Math.random()); // Pretty much unpredictable x.
|
|
|
|
var rng = new Math.seedrandom(seed); // A new prng with the same seed.
|
|
document.write(rng()); // Repeat the 'unpredictable' x.
|
|
|
|
function reseed(event, count) { // Define a custom entropy collector.
|
|
var t = [];
|
|
function w(e) {
|
|
t.push([e.pageX, e.pageY, +new Date]);
|
|
if (t.length < count) { return; }
|
|
document.removeEventListener(event, w);
|
|
Math.seedrandom(t, { entropy: true });
|
|
}
|
|
document.addEventListener(event, w);
|
|
}
|
|
reseed('mousemove', 100); // Reseed after 100 mouse moves.
|
|
|
|
The "pass" option can be used to get both the prng and the seed.
|
|
The following returns both an autoseeded prng and the seed as an object,
|
|
without mutating Math.random:
|
|
|
|
var obj = Math.seedrandom(null, { pass: function(prng, seed) {
|
|
return { random: prng, seed: seed };
|
|
}});
|
|
|
|
|
|
Version notes
|
|
-------------
|
|
|
|
The random number sequence is the same as version 1.0 for string seeds.
|
|
* Version 2.0 changed the sequence for non-string seeds.
|
|
* Version 2.1 speeds seeding and uses window.crypto to autoseed if present.
|
|
* Version 2.2 alters non-crypto autoseeding to sweep up entropy from plugins.
|
|
* Version 2.3 adds support for "new", module loading, and a null seed arg.
|
|
* Version 2.3.1 adds a build environment, module packaging, and tests.
|
|
* Version 2.3.4 fixes bugs on IE8, and switches to MIT license.
|
|
* Version 2.3.6 adds a readable options object argument.
|
|
* Version 2.3.10 adds support for node.js crypto (contributed by ctd1500).
|
|
|
|
The standard ARC4 key scheduler cycles short keys, which means that
|
|
seedrandom('ab') is equivalent to seedrandom('abab') and 'ababab'.
|
|
Therefore it is a good idea to add a terminator to avoid trivial
|
|
equivalences on short string seeds, e.g., Math.seedrandom(str + '\0').
|
|
Starting with version 2.0, a terminator is added automatically for
|
|
non-string seeds, so seeding with the number 111 is the same as seeding
|
|
with '111\0'.
|
|
|
|
When seedrandom() is called with zero args or a null seed, it uses a
|
|
seed drawn from the browser crypto object if present. If there is no
|
|
crypto support, seedrandom() uses the current time, the native rng,
|
|
and a walk of several DOM objects to collect a few bits of entropy.
|
|
|
|
Each time the one- or two-argument forms of seedrandom are called,
|
|
entropy from the passed seed is accumulated in a pool to help generate
|
|
future seeds for the zero- and two-argument forms of seedrandom.
|
|
|
|
On speed - This javascript implementation of Math.random() is several
|
|
times slower than the built-in Math.random() because it is not native
|
|
code, but that is typically fast enough. Some details (timings on
|
|
Chrome 25 on a 2010 vintage macbook):
|
|
|
|
* seeded Math.random() - avg less than 0.0002 milliseconds per call
|
|
* seedrandom('explicit.') - avg less than 0.2 milliseconds per call
|
|
* seedrandom('explicit.', true) - avg less than 0.2 milliseconds per call
|
|
* seedrandom() with crypto - avg less than 0.2 milliseconds per call
|
|
|
|
Autoseeding without crypto is somewhat slower, about 20-30 milliseconds on
|
|
a 2012 windows 7 1.5ghz i5 laptop, as seen on Firefox 19, IE 10, and Opera.
|
|
Seeded rng calls themselves are fast across these browsers, with slowest
|
|
numbers on Opera at about 0.0005 ms per seeded Math.random().
|
|
|
|
|
|
LICENSE (MIT)
|
|
-------------
|
|
|
|
Copyright 2014 David Bau.
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining
|
|
a copy of this software and associated documentation files (the
|
|
"Software"), to deal in the Software without restriction, including
|
|
without limitation the rights to use, copy, modify, merge, publish,
|
|
distribute, sublicense, and/or sell copies of the Software, and to
|
|
permit persons to whom the Software is furnished to do so, subject to
|
|
the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be
|
|
included in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
/**
|
|
* All code is in an anonymous closure to keep the global namespace clean.
|
|
*/
|
|
(function (
|
|
global, pool, math, width, chunks, digits, module, define, rngname) {
|
|
|
|
//
|
|
// The following constants are related to IEEE 754 limits.
|
|
//
|
|
var startdenom = math.pow(width, chunks),
|
|
significance = math.pow(2, digits),
|
|
overflow = significance * 2,
|
|
mask = width - 1,
|
|
nodecrypto;
|
|
|
|
//
|
|
// seedrandom()
|
|
// This is the seedrandom function described above.
|
|
//
|
|
var impl = math['seed' + rngname] = function(seed, options, callback) {
|
|
var key = [];
|
|
options = (options == true) ? { entropy: true } : (options || {});
|
|
|
|
// Flatten the seed string or build one from local entropy if needed.
|
|
var shortseed = mixkey(flatten(
|
|
options.entropy ? [seed, tostring(pool)] :
|
|
(seed == null) ? autoseed() : seed, 3), key);
|
|
|
|
// Use the seed to initialize an ARC4 generator.
|
|
var arc4 = new ARC4(key);
|
|
|
|
// Mix the randomness into accumulated entropy.
|
|
mixkey(tostring(arc4.S), pool);
|
|
|
|
// Calling convention: what to return as a function of prng, seed, is_math.
|
|
return (options.pass || callback ||
|
|
// If called as a method of Math (Math.seedrandom()), mutate Math.random
|
|
// because that is how seedrandom.js has worked since v1.0. Otherwise,
|
|
// it is a newer calling convention, so return the prng directly.
|
|
function(prng, seed, is_math_call) {
|
|
if (is_math_call) { math[rngname] = prng; return seed; }
|
|
else return prng;
|
|
})(
|
|
|
|
// This function returns a random double in [0, 1) that contains
|
|
// randomness in every bit of the mantissa of the IEEE 754 value.
|
|
function() {
|
|
var n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48
|
|
d = startdenom, // and denominator d = 2 ^ 48.
|
|
x = 0; // and no 'extra last byte'.
|
|
while (n < significance) { // Fill up all significant digits by
|
|
n = (n + x) * width; // shifting numerator and
|
|
d *= width; // denominator and generating a
|
|
x = arc4.g(1); // new least-significant-byte.
|
|
}
|
|
while (n >= overflow) { // To avoid rounding up, before adding
|
|
n /= 2; // last byte, shift everything
|
|
d /= 2; // right using integer math until
|
|
x >>>= 1; // we have exactly the desired bits.
|
|
}
|
|
return (n + x) / d; // Form the number within [0, 1).
|
|
}, shortseed, 'global' in options ? options.global : (this == math));
|
|
};
|
|
|
|
//
|
|
// ARC4
|
|
//
|
|
// An ARC4 implementation. The constructor takes a key in the form of
|
|
// an array of at most (width) integers that should be 0 <= x < (width).
|
|
//
|
|
// The g(count) method returns a pseudorandom integer that concatenates
|
|
// the next (count) outputs from ARC4. Its return value is a number x
|
|
// that is in the range 0 <= x < (width ^ count).
|
|
//
|
|
/** @constructor */
|
|
function ARC4(key) {
|
|
var t, keylen = key.length,
|
|
me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
|
|
|
|
// The empty key [] is treated as [0].
|
|
if (!keylen) { key = [keylen++]; }
|
|
|
|
// Set up S using the standard key scheduling algorithm.
|
|
while (i < width) {
|
|
s[i] = i++;
|
|
}
|
|
for (i = 0; i < width; i++) {
|
|
s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];
|
|
s[j] = t;
|
|
}
|
|
|
|
// The "g" method returns the next (count) outputs as one number.
|
|
(me.g = function(count) {
|
|
// Using instance members instead of closure state nearly doubles speed.
|
|
var t, r = 0,
|
|
i = me.i, j = me.j, s = me.S;
|
|
while (count--) {
|
|
t = s[i = mask & (i + 1)];
|
|
r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];
|
|
}
|
|
me.i = i; me.j = j;
|
|
return r;
|
|
// For robust unpredictability, the function call below automatically
|
|
// discards an initial batch of values. This is called RC4-drop[256].
|
|
// See http://google.com/search?q=rsa+fluhrer+response&btnI
|
|
})(width);
|
|
}
|
|
|
|
//
|
|
// flatten()
|
|
// Converts an object tree to nested arrays of strings.
|
|
//
|
|
function flatten(obj, depth) {
|
|
var result = [], typ = (typeof obj), prop;
|
|
if (depth && typ == 'object') {
|
|
for (prop in obj) {
|
|
try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}
|
|
}
|
|
}
|
|
return (result.length ? result : typ == 'string' ? obj : obj + '\0');
|
|
}
|
|
|
|
//
|
|
// mixkey()
|
|
// Mixes a string seed into a key that is an array of integers, and
|
|
// returns a shortened string seed that is equivalent to the result key.
|
|
//
|
|
function mixkey(seed, key) {
|
|
var stringseed = seed + '', smear, j = 0;
|
|
while (j < stringseed.length) {
|
|
key[mask & j] =
|
|
mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));
|
|
}
|
|
return tostring(key);
|
|
}
|
|
|
|
//
|
|
// autoseed()
|
|
// Returns an object for autoseeding, using window.crypto if available.
|
|
//
|
|
/** @param {Uint8Array|Navigator=} seed */
|
|
function autoseed(seed) {
|
|
try {
|
|
if (nodecrypto) return tostring(nodecrypto.randomBytes(width));
|
|
global.crypto.getRandomValues(seed = new Uint8Array(width));
|
|
return tostring(seed);
|
|
} catch (e) {
|
|
return [+new Date, global, (seed = global.navigator) && seed.plugins,
|
|
global.screen, tostring(pool)];
|
|
}
|
|
}
|
|
|
|
//
|
|
// tostring()
|
|
// Converts an array of charcodes to a string
|
|
//
|
|
function tostring(a) {
|
|
return String.fromCharCode.apply(0, a);
|
|
}
|
|
|
|
//
|
|
// When seedrandom.js is loaded, we immediately mix a few bits
|
|
// from the built-in RNG into the entropy pool. Because we do
|
|
// not want to interfere with deterministic PRNG state later,
|
|
// seedrandom will not call math.random on its own again after
|
|
// initialization.
|
|
//
|
|
mixkey(math[rngname](), pool);
|
|
|
|
//
|
|
// Nodejs and AMD support: export the implementation as a module using
|
|
// either convention.
|
|
//
|
|
if (module && module.exports) {
|
|
module.exports = impl;
|
|
try {
|
|
// When in node.js, try using crypto package for autoseeding.
|
|
nodecrypto = require('crypto');
|
|
} catch (ex) {}
|
|
} else if (define && define.amd) {
|
|
define(function() { return impl; });
|
|
}
|
|
|
|
//
|
|
// Node.js native crypto support.
|
|
//
|
|
|
|
// End anonymous scope, and pass initial values.
|
|
})(
|
|
this, // global window object
|
|
[], // pool: entropy pool starts empty
|
|
Math, // math: package containing random, pow, and seedrandom
|
|
256, // width: each RC4 output is 0 <= x < 256
|
|
6, // chunks: at least six RC4 outputs for each double
|
|
52, // digits: there are 52 significant digits in a double
|
|
(typeof module) == 'object' && module, // present in node.js
|
|
(typeof define) == 'function' && define, // present with an AMD loader
|
|
'random'// rngname: name for Math.random and Math.seedrandom
|
|
);
|