Cryptographically Secure Pseudorandom Number Generator Puns

In this paper by Santha-Vazirani, they talk about creating quasi-random numbers from "weak" random numbers. What's considered a "weak" random number? Would JS's Math.random() count as a "weak" random number generator? If not, what are some implementations of the discussion of this paper?

What makes a pseudorandom number generator have a long sequence, and how do we figure out how to make a PRNG with a long sequence? Is there some mathematical way to figure out the best program for an incredibly long and random sequence? Or is it just random guessing using intuition?

For those like myself who don’t have the option to abuse cloud saving, the ability to manipulate the pseudorandom number generator is extremely limited, as restarting the game when you faint will only rewind to the beginning of the turn you fainted on (before you selected your input), and due to the way pseudorandom number generators work, performing the same input will always yield the same outcome, and sometimes you’ll have even less wiggle-room than that. I recently found myself in such a scenario:

It was floor 48 of Purity Forrest (yes, from the same run I started yesterday, I like to make progress in chunks), my Cradily was fatally wounded and confused. The Golbat’s next move would always be a wing attack, which would always finish me off. To my dismay, no matter what attack I selected, and what direction I attempted to use it in, the game would always have me use it on the bottom-left tile, while the Golbat was on the top centre tile. Moving wasn’t much help either, no matter what direction I inputted, the game would always move me to the top-right tile, right next to the Golbat. Time and time again I had to watch the map preemptively remove all the icons as soon as I made my input, informing me that I would not survive to the next turn. And then, merely on a whim, I decided to press A instead, for the auto-attack, and to my surprise, Cradily faced the top centre tile, and used Brine, gaining the damage bonus and finishing off the Golbat....

So it would seem as though when you are confused, the game decides what tile you will face when selecting an attack, regardless of what attack you select, but for whatever reason, it picks a second tile for your attack direction if instead of choosing the move you use, you press A and let the game decide for you. Pseudorandom number generators are curious things indeed!

The random number generator controls the spawn rate of the landscape and the animals while the pseudorandom number generator controls people’s personalities and their interactions with everything around them

Let's say we have a malicious program with minimal system access whose goal is to gather as much information about the computer it's running on as possible. One of the few resources it can access is the operating system's random and pseudorandom number generators. Since random numbers require a seed that is usually in the form of data about the user, like mouse movements or sensor data, could abusing a computer's random/pseudorandom number generator theoretically allow the malicious program to determine the seed and the data which created it? Would this be possible with a modern operating system or are there mitigations against it?

For example, since mobile phones typically use sensors like the accelerometer to create the seed, and accelerometer data can be used to determine whether the person using the phone is moving or standing still, could a spyware that normally wouldn't be able to read accelerometer data use the random or pseudorandom number generator to figure out the accelerometer data and determine whether the user is moving? Using this method, would the program get a somewhat continuous stream of accelerometer data or only a few individual values?

Short survey of non-standard pseudorandom number generators.

Google and wikipedia tend to produce the persistent illusion that only a handful of PRNGs are useful or even known. Among these regular standbys, Blum-Blum-Shub, Mersenne twister, LFSR, lagged Fibonacci generator, the middle column of CA Rule 30, et cetera

The true variety of PRNGs is much larger. Particularly when our interest in them goes beyond merely their statistical properties. Here I present six unusual generators along with supplied source code examples.

• Blowfish generator - http://pastebin.com/gn2bVWQA

• Von Neumann Extractor - http://pastebin.com/1cnyVNwK

• Bit Selector - http://pastebin.com/hJVnyZYD

• Low-dimensional prime trap - http://pastebin.com/4WnFHUh2

• High-dimensional prime trap - http://pastebin.com/E3urvPuq

• Fractal logarithm generator - http://pastebin.com/EnM48B90

"Several computational methods for random number generation exist. Many fall short of the goal of true randomness — though they may meet, with varying success, some of the statistical tests for randomness intended to measure how unpredictable their results are (that is, to what degree their patterns are discernible)." -Wikipedia on Random Number Generators

The Wiki talks about inherent flaws in the Computational Random Number Generators that don't allow them to achieve true randomness; but doesn't explain what "tests" they don't pass.

Can anyone show me an example of a RNG showing a flaw in the number generated?

TL;DR run the following command as root, change the group and user on the new urandom device, and set the "random-device" option in named.conf to "/dev/urandom"

sudo mknod /srv/named/dev/urandom c 1 9

I run a DNS server at home on an Arch box. I followed the instructions on the Arch Wiki for installing named in a chroot environment. Last night I did a system update and it stopped working throwing the following error:

openssl_link.c:296: fatal error:
OpenSSL pseudorandom number generator cannot be initialized (see the `PRNG not seeded' message in the OpenSSL FAQ)
exiting (due to fatal error in library)

After some googling, I found this bug. Following it, looks like /dev/random isn't getting enough entropy. Adding a pseudorandom number generator device fixed it.

Anyway, in case someone needed a quick fix, I thought I'd add this to subreddit.

so I've gotten to the game assignment and thought I've made something pretty nice. a light blinks in the middle with a randomly generated delay and depending on how fast you press the button, you get a green, orange or red light. enjoy

https://vimeo.com/202885839

Hey /r/ProgrammerHumor! I just cooked up a little random thingy for the Unix fellows among us. the "Has Satan infected your blocking pseudorandom number generator test™"

Here's how to play:
cat /dev/urandom | hexdump -C | cut -d '|' -f 2 | tr -d '.' | grep -o 666

Alternatively, you can cat /dev/urandom | hexdump -C | cut -d '|' -f 2 | tr -d '.' | grep -o satan, but that takes a lo^o^o^o^o^o^o^o^o^o^o^o^ong time before it hits anything. (trust me, I waited a few weeks for that one)

http://i.imgur.com/18juQ.png

http://i.imgur.com/iumhN.png

This is an 8-bit linear feedback shift register. Output is three bits, for numbers 0-7, displayed with redstone torches in the form of the face of a die.

The shift register consists of the eight green D flip flops toward the the right side of the circuit; the taps at the back are input to the three orange XOR gates and fed back into the end bit. It's driven by the clock / pulse generator in red just to the left.

When the button beside the die face is pressed, the adjacent green RS-NOR latch is set; when that latch is set and the pulse generator goes down after shifting the register, the orange AND gate between them clocks the three yellow D flip flops, setting them equal to the last three bits of the register, and also resets the latch for the next request (i.e., when you press the button, it waits until the shift register stabilizes before displaying the result).

The die face always displays the value of the yellow flip flops, via the orange logic behind it.

I was reading about pseudorandom number generation, and I was wondering what Java uses in it's Math.random() and the Random utility class to generate random numbers. What I am kinda asking is, does Java use this linear congruential generator, or something else?

I have a sharp el-506W. It has a pseudorandom number generator that store a 10 digit (as far as i checked) random number stored in the variable Y. The number is a real number between 0 and 1, extremes excluded.

Can i safely assume that the probability density over those ten billion decimal numbers is uniform? Do you know if PRNG (pseudorandom number generators) on calculators have certain limits and are skewed? If yes, do you know any reason? (maybe limited hw?)

I'm currently a math/computer-science major, and this topic really interested me.

So here's the deal: A computer is essentially an enormous circuit (I'm a computer scientist, not an electrical engineer, so my knowledge here gets hazy). You can input information to this machine with keyboards and mice, and you receive output through the screen and speakers, etc.

I understand computers in terms of inputs and outputs. I input certain data, and I receive an expected result from the program I'm running.

So, how does a computer generate pseudorandom data? How do number generators work? How "random" is this data?