Petr Balashov
8 years ago
5 changed files with 640 additions and 0 deletions
@ -0,0 +1,8 @@ |
|||
import { PassPhraseGenerator } from './crypto/passphrasegenerator.js'; |
|||
import { md5 } from './crypto/md5.js'; |
|||
|
|||
export function iguanaSetRPCAuth() { |
|||
var tmpPass = md5(PassPhraseGenerator.generatePassPhrase(128)); |
|||
sessionStorage.setItem('IguanaRPCAuth', tmpPass); |
|||
console.log('passphraseGen', tmpPass); |
|||
} |
|||
@ -0,0 +1,201 @@ |
|||
// ref: https://css-tricks.com/snippets/javascript/javascript-md5/
|
|||
|
|||
export const md5 = function (string) { |
|||
function RotateLeft(lValue, iShiftBits) { |
|||
return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits)); |
|||
} |
|||
|
|||
function AddUnsigned(lX,lY) { |
|||
var lX4,lY4,lX8,lY8,lResult; |
|||
lX8 = (lX & 0x80000000); |
|||
lY8 = (lY & 0x80000000); |
|||
lX4 = (lX & 0x40000000); |
|||
lY4 = (lY & 0x40000000); |
|||
lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF); |
|||
if (lX4 & lY4) { |
|||
return (lResult ^ 0x80000000 ^ lX8 ^ lY8); |
|||
} |
|||
if (lX4 | lY4) { |
|||
if (lResult & 0x40000000) { |
|||
return (lResult ^ 0xC0000000 ^ lX8 ^ lY8); |
|||
} else { |
|||
return (lResult ^ 0x40000000 ^ lX8 ^ lY8); |
|||
} |
|||
} else { |
|||
return (lResult ^ lX8 ^ lY8); |
|||
} |
|||
} |
|||
|
|||
function F(x,y,z) { return (x & y) | ((~x) & z); } |
|||
function G(x,y,z) { return (x & z) | (y & (~z)); } |
|||
function H(x,y,z) { return (x ^ y ^ z); } |
|||
function I(x,y,z) { return (y ^ (x | (~z))); } |
|||
|
|||
function FF(a,b,c,d,x,s,ac) { |
|||
a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac)); |
|||
return AddUnsigned(RotateLeft(a, s), b); |
|||
}; |
|||
|
|||
function GG(a,b,c,d,x,s,ac) { |
|||
a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac)); |
|||
return AddUnsigned(RotateLeft(a, s), b); |
|||
}; |
|||
|
|||
function HH(a,b,c,d,x,s,ac) { |
|||
a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac)); |
|||
return AddUnsigned(RotateLeft(a, s), b); |
|||
}; |
|||
|
|||
function II(a,b,c,d,x,s,ac) { |
|||
a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac)); |
|||
return AddUnsigned(RotateLeft(a, s), b); |
|||
}; |
|||
|
|||
function ConvertToWordArray(string) { |
|||
var lWordCount; |
|||
var lMessageLength = string.length; |
|||
var lNumberOfWords_temp1=lMessageLength + 8; |
|||
var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64; |
|||
var lNumberOfWords = (lNumberOfWords_temp2+1)*16; |
|||
var lWordArray=Array(lNumberOfWords-1); |
|||
var lBytePosition = 0; |
|||
var lByteCount = 0; |
|||
while ( lByteCount < lMessageLength ) { |
|||
lWordCount = (lByteCount-(lByteCount % 4))/4; |
|||
lBytePosition = (lByteCount % 4)*8; |
|||
lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount)<<lBytePosition)); |
|||
lByteCount++; |
|||
} |
|||
lWordCount = (lByteCount-(lByteCount % 4))/4; |
|||
lBytePosition = (lByteCount % 4)*8; |
|||
lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition); |
|||
lWordArray[lNumberOfWords-2] = lMessageLength<<3; |
|||
lWordArray[lNumberOfWords-1] = lMessageLength>>>29; |
|||
return lWordArray; |
|||
}; |
|||
|
|||
function WordToHex(lValue) { |
|||
var WordToHexValue="",WordToHexValue_temp="",lByte,lCount; |
|||
for (lCount = 0;lCount<=3;lCount++) { |
|||
lByte = (lValue>>>(lCount*8)) & 255; |
|||
WordToHexValue_temp = "0" + lByte.toString(16); |
|||
WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2); |
|||
} |
|||
return WordToHexValue; |
|||
}; |
|||
|
|||
function Utf8Encode(string) { |
|||
string = string.replace(/\r\n/g,"\n"); |
|||
var utftext = ""; |
|||
|
|||
for (var n = 0; n < string.length; n++) { |
|||
|
|||
var c = string.charCodeAt(n); |
|||
|
|||
if (c < 128) { |
|||
utftext += String.fromCharCode(c); |
|||
} |
|||
else if((c > 127) && (c < 2048)) { |
|||
utftext += String.fromCharCode((c >> 6) | 192); |
|||
utftext += String.fromCharCode((c & 63) | 128); |
|||
} |
|||
else { |
|||
utftext += String.fromCharCode((c >> 12) | 224); |
|||
utftext += String.fromCharCode(((c >> 6) & 63) | 128); |
|||
utftext += String.fromCharCode((c & 63) | 128); |
|||
} |
|||
|
|||
} |
|||
|
|||
return utftext; |
|||
}; |
|||
|
|||
var x=Array(); |
|||
var k,AA,BB,CC,DD,a,b,c,d; |
|||
var S11=7, S12=12, S13=17, S14=22; |
|||
var S21=5, S22=9 , S23=14, S24=20; |
|||
var S31=4, S32=11, S33=16, S34=23; |
|||
var S41=6, S42=10, S43=15, S44=21; |
|||
|
|||
string = Utf8Encode(string); |
|||
|
|||
x = ConvertToWordArray(string); |
|||
|
|||
a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476; |
|||
|
|||
for (k=0;k<x.length;k+=16) { |
|||
AA=a; BB=b; CC=c; DD=d; |
|||
a=FF(a,b,c,d,x[k+0], S11,0xD76AA478); |
|||
d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756); |
|||
c=FF(c,d,a,b,x[k+2], S13,0x242070DB); |
|||
b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE); |
|||
a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF); |
|||
d=FF(d,a,b,c,x[k+5], S12,0x4787C62A); |
|||
c=FF(c,d,a,b,x[k+6], S13,0xA8304613); |
|||
b=FF(b,c,d,a,x[k+7], S14,0xFD469501); |
|||
a=FF(a,b,c,d,x[k+8], S11,0x698098D8); |
|||
d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF); |
|||
c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1); |
|||
b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE); |
|||
a=FF(a,b,c,d,x[k+12],S11,0x6B901122); |
|||
d=FF(d,a,b,c,x[k+13],S12,0xFD987193); |
|||
c=FF(c,d,a,b,x[k+14],S13,0xA679438E); |
|||
b=FF(b,c,d,a,x[k+15],S14,0x49B40821); |
|||
a=GG(a,b,c,d,x[k+1], S21,0xF61E2562); |
|||
d=GG(d,a,b,c,x[k+6], S22,0xC040B340); |
|||
c=GG(c,d,a,b,x[k+11],S23,0x265E5A51); |
|||
b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA); |
|||
a=GG(a,b,c,d,x[k+5], S21,0xD62F105D); |
|||
d=GG(d,a,b,c,x[k+10],S22,0x2441453); |
|||
c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681); |
|||
b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8); |
|||
a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6); |
|||
d=GG(d,a,b,c,x[k+14],S22,0xC33707D6); |
|||
c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87); |
|||
b=GG(b,c,d,a,x[k+8], S24,0x455A14ED); |
|||
a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905); |
|||
d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8); |
|||
c=GG(c,d,a,b,x[k+7], S23,0x676F02D9); |
|||
b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A); |
|||
a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942); |
|||
d=HH(d,a,b,c,x[k+8], S32,0x8771F681); |
|||
c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122); |
|||
b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C); |
|||
a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44); |
|||
d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9); |
|||
c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60); |
|||
b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70); |
|||
a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6); |
|||
d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA); |
|||
c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085); |
|||
b=HH(b,c,d,a,x[k+6], S34,0x4881D05); |
|||
a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039); |
|||
d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5); |
|||
c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8); |
|||
b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665); |
|||
a=II(a,b,c,d,x[k+0], S41,0xF4292244); |
|||
d=II(d,a,b,c,x[k+7], S42,0x432AFF97); |
|||
c=II(c,d,a,b,x[k+14],S43,0xAB9423A7); |
|||
b=II(b,c,d,a,x[k+5], S44,0xFC93A039); |
|||
a=II(a,b,c,d,x[k+12],S41,0x655B59C3); |
|||
d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92); |
|||
c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D); |
|||
b=II(b,c,d,a,x[k+1], S44,0x85845DD1); |
|||
a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F); |
|||
d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0); |
|||
c=II(c,d,a,b,x[k+6], S43,0xA3014314); |
|||
b=II(b,c,d,a,x[k+13],S44,0x4E0811A1); |
|||
a=II(a,b,c,d,x[k+4], S41,0xF7537E82); |
|||
d=II(d,a,b,c,x[k+11],S42,0xBD3AF235); |
|||
c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB); |
|||
b=II(b,c,d,a,x[k+9], S44,0xEB86D391); |
|||
a=AddUnsigned(a,AA); |
|||
b=AddUnsigned(b,BB); |
|||
c=AddUnsigned(c,CC); |
|||
d=AddUnsigned(d,DD); |
|||
} |
|||
|
|||
var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d); |
|||
|
|||
return temp.toLowerCase(); |
|||
} |
|||
@ -0,0 +1,87 @@ |
|||
/****************************************************************************** |
|||
* Copyright © 2016 The Waves Core Developers. * |
|||
* * |
|||
* See the LICENSE files at * |
|||
* the top-level directory of this distribution for the individual copyright * |
|||
* holder information and the developer policies on copyright and licensing. * |
|||
* * |
|||
* Unless otherwise agreed in a custom licensing agreement, no part of the * |
|||
* Waves software, including this file, may be copied, modified, propagated, * |
|||
* or distributed except according to the terms contained in the LICENSE.txt * |
|||
* file. * |
|||
* * |
|||
* Removal or modification of this copyright notice is prohibited. * |
|||
* * |
|||
******************************************************************************/ |
|||
|
|||
/** |
|||
* @depends {../3rdparty/jquery-2.1.0.js} |
|||
*/ |
|||
|
|||
import { ClientWordList } from './wordlist.js'; |
|||
|
|||
export const PassPhraseGenerator = { |
|||
seeds: 0, |
|||
seedLimit: 512, |
|||
|
|||
push: function(seed) { |
|||
Math.seedrandom(seed, true); |
|||
this.seeds++; |
|||
}, |
|||
|
|||
isDone: function() { |
|||
if (this.seeds == this.seedLimit) { |
|||
return true; |
|||
} |
|||
return false; |
|||
}, |
|||
|
|||
percentage: function() { |
|||
return Math.round((this.seeds / this.seedLimit) * 100) |
|||
}, |
|||
|
|||
passPhrase: "", |
|||
|
|||
wordCount: 2048, |
|||
|
|||
words: ClientWordList, |
|||
|
|||
generatePassPhrase: function(bitsval) { |
|||
|
|||
var crypto = window.crypto || window.msCrypto; |
|||
|
|||
var bits = bitsval; |
|||
|
|||
var random = new Uint32Array(bits / 32); |
|||
|
|||
crypto.getRandomValues(random); |
|||
|
|||
var i = 0, |
|||
l = random.length, |
|||
n = this.wordCount, |
|||
words = [], |
|||
x, w1, w2, w3; |
|||
|
|||
for (; i < l; i++) { |
|||
x = random[i]; |
|||
w1 = x % n; |
|||
w2 = (((x / n) >> 0) + w1) % n; |
|||
w3 = (((((x / n) >> 0) / n) >> 0) + w2) % n; |
|||
|
|||
words.push(this.words[w1]); |
|||
words.push(this.words[w2]); |
|||
words.push(this.words[w3]); |
|||
} |
|||
|
|||
this.passPhrase = words.join(" "); |
|||
|
|||
crypto.getRandomValues(random); |
|||
|
|||
return this.passPhrase; |
|||
}, |
|||
|
|||
reset: function() { |
|||
this.passPhrase = ""; |
|||
this.seeds = 0; |
|||
} |
|||
} |
|||
@ -0,0 +1,342 @@ |
|||
// seedrandom.js version 2.3.3
|
|||
// Author: David Bau
|
|||
// Date: 2014 Feb 4
|
|||
//
|
|||
// Defines a method Math.seedrandom() that, when called, substitutes
|
|||
// an explicitly seeded RC4-based algorithm for Math.random(). Also
|
|||
// supports automatic seeding from local or network sources of entropy.
|
|||
// Can be used as a node.js or AMD module. Can be called with "new"
|
|||
// to create a local PRNG without changing Math.random.
|
|||
//
|
|||
// Basic usage:
|
|||
//
|
|||
// <script src=http://davidbau.com/encode/seedrandom.min.js></script>
|
|||
//
|
|||
// Math.seedrandom('yay.'); // Sets Math.random to a function that is
|
|||
// // initialized using the given explicit seed.
|
|||
//
|
|||
// Math.seedrandom(); // Sets Math.random to a function that is
|
|||
// // seeded using the current time, dom state,
|
|||
// // and other accumulated local entropy.
|
|||
// // The generated seed string is returned.
|
|||
//
|
|||
// Math.seedrandom('yowza.', true);
|
|||
// // Seeds using the given explicit seed mixed
|
|||
// // together with accumulated entropy.
|
|||
//
|
|||
// <script src="https://jsonlib.appspot.com/urandom?callback=Math.seedrandom">
|
|||
// </script> <!-- Seeds using urandom bits from a server. -->
|
|||
//
|
|||
// Math.seedrandom("hello."); // Behavior is the same everywhere:
|
|||
// document.write(Math.random()); // Always 0.9282578795792454
|
|||
// document.write(Math.random()); // Always 0.3752569768646784
|
|||
//
|
|||
// Math.seedrandom can be used as a constructor to return a seeded PRNG
|
|||
// that is independent of Math.random:
|
|||
//
|
|||
// var myrng = new Math.seedrandom('yay.');
|
|||
// var n = myrng(); // Using "new" creates a local prng without
|
|||
// // altering Math.random.
|
|||
//
|
|||
// When used as a module, seedrandom is a function that returns a seeded
|
|||
// PRNG instance without altering Math.random:
|
|||
//
|
|||
// // With node.js (after "npm install seedrandom"):
|
|||
// var seedrandom = require('seedrandom');
|
|||
// var rng = seedrandom('hello.');
|
|||
// console.log(rng()); // always 0.9282578795792454
|
|||
//
|
|||
// // With require.js or other AMD loader:
|
|||
// require(['seedrandom'], function(seedrandom) {
|
|||
// var rng = seedrandom('hello.');
|
|||
// console.log(rng()); // always 0.9282578795792454
|
|||
// });
|
|||
//
|
|||
// More examples:
|
|||
//
|
|||
// 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, true); // Mix in any previous entropy.
|
|||
// }
|
|||
// document.addEventListener(event, w);
|
|||
// }
|
|||
// reseed('mousemove', 100); // Reseed after 100 mouse moves.
|
|||
//
|
|||
// The callback third arg 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, false, 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.3 fixes bugs on IE8, and switches to MIT license.
|
|||
//
|
|||
// 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 (BSD):
|
|||
//
|
|||
// Copyright 2013 David Bau, all rights reserved.
|
|||
//
|
|||
// Redistribution and use in source and binary forms, with or without
|
|||
// modification, are permitted provided that the following conditions are met:
|
|||
//
|
|||
// 1. Redistributions of source code must retain the above copyright
|
|||
// notice, this list of conditions and the following disclaimer.
|
|||
//
|
|||
// 2. Redistributions in binary form must reproduce the above copyright
|
|||
// notice, this list of conditions and the following disclaimer in the
|
|||
// documentation and/or other materials provided with the distribution.
|
|||
//
|
|||
// 3. Neither the name of this module nor the names of its contributors may
|
|||
// be used to endorse or promote products derived from this software
|
|||
// without specific prior written permission.
|
|||
//
|
|||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|||
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|||
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|||
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|||
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|||
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|||
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|||
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|||
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
//
|
|||
|
|||
/** |
|||
* 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, |
|||
|
|||
//
|
|||
// seedrandom()
|
|||
// This is the seedrandom function described above.
|
|||
//
|
|||
impl = math['seed' + rngname] = function(seed, use_entropy, callback) { |
|||
var key = []; |
|||
|
|||
// Flatten the seed string or build one from local entropy if needed.
|
|||
var shortseed = mixkey(flatten( |
|||
use_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 (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, 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 discard an initial batch of values.
|
|||
// See http://www.rsa.com/rsalabs/node.asp?id=2009
|
|||
})(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 { |
|||
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 intefere with determinstic 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 implemenation as a module using
|
|||
// either convention.
|
|||
//
|
|||
if (module && module.exports) { |
|||
module.exports = impl; |
|||
} else if (define && define.amd) { |
|||
define(function() { return impl; }); |
|||
} |
|||
|
|||
// 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
|
|||
); |
|||
File diff suppressed because one or more lines are too long
Loading…
Reference in new issue