Clock Based

One of the more common (and easiest to exploit) ways random numbers are generated is with the internal clock of the computer itself. To create a random number digitally you have to base it off of something, and the one and only thing in a computer that changes over time is the clock itself. You can't create something random from something that is constant.

Clock based takes the internal clock of the computer and uses the "DateTime" object itself. Let's say the time right now is "November 15th 2005, 1:16:39 AM". Regardless of what time it is, you have a few different options as to how to manipulate the DateTime to your randomness-liking. You could use the literal MMDDYYhhmmss value: 111505011639 and turn that into a number itself (111,505,011,639), or you could count how many seconds are between 'right now' and a previous date of your choosing. Comparing the example DateTime to "January 1st 2000, 12:00:00 AM" would result in: 185,332,599 seconds. Determining which method to use, or other custom-methods as created by the imagination of the programmer, is usually totally up to the programmer. Whatever the case may be, you should now understand how this form of (clock) randomness is used. For the sake of examples later we will say the clock based determination for 'right now' is 111,505,011,639.

Bit Based

This method of generating random numbers really only goes one step further than clock based randomness. It works exactly the same way as clock based, with a few extra steps. Bit based is a little more complex of a method as compared to clock based, making it a little more tedious to reverse engineer, but it can still be exploited none-the-less. (I have seen this also called "seed based" because it takes the 'seed' of the end result bit string and uses it as the randomness object. For the sake of this paper, Seed based and Bit based are 2 completely different things).

Refer to how clock based randomness is created. Now, take this end result number and figure out its bits and bytes (hence why this is called Bit Based). The bit value for 12,345 is 11000000111001, the bit value for 777,777 is 10111101111000110001, the bit value for 77 is 1001101, the bit value for 5 is 101. (See how a number is converted to a bit string, and a bit string is converted into a number: click here ) However what I'm trying to demonstrate is that a string of bits has no distinct length. 5 is 3 characters long, 77 is 7 characters long, 12,345 is 14 characters long... Calculating the bit value for a large number such as the clock based example of 185,332,599 or even 111,505,011,639 is pretty large and would take more than a few seconds for a standard home PC to calculate its bit value. Speed is extremely important in applications (a programmer's program) so each random number taking many seconds to generate is 'bad programming'. To speed it up, lets say they choose to take the last 6 characters of a number larger than 6 characters. 111,505,011,639 would become 011,639 or 11,639. The bit value for 11,639 is 10110101110111. After knowing the bits, you can alter them however you like, almost like shuffling a deck of cards but not actually changing how many cards you started with or what was on the cards. For the sake of this example, we will simply be flip flopping the bits. 1234 becomes 4321.. or 10110101110111 becomes 11101110101101... and 11101110101101 equals 15277. (11639 becomes 15277)

Seed Based

This method takes a completely different approach, it relies far less heavily on a clock. To some extent this makes it harder to reverse engineer. When a computer or the program first loads, it has a starting 'seed' to work with. The starting value could be a clock based, bit based, or any other 'simple randomness' number, or it could be the same number 'hardcoded' into the program to start with the same start number every time, it doesnt really matter what the start number is altho knowing what it is is helpful to exploit it. The key to this method is how that number evolves or grows.

One of my favorite mathematical patterns is 112358... Every subsequent number is the sum of the previous 2 numbers. This is an example of how a number grows. How this seed based method number grows is partially up to the programmer of this random function. Simply creating an algebra equation to make the number grow isn't enough so the clock's seconds or milliseconds are used as multipliers or other types of variables in the equation. Custom created random number generators are tedious and painful to create, and I highly recommend if you are a programmer to just use what someone else has already created: Abuse their hard work, its the honest thing to do. However, trying to understand how this works, I'll give a simple example (as compared to the math involved to make an almost 'unbreakable' random number generator).

Example: My seed based generator will start with the seed of right now's ("Minutes"+"Seconds")+1 which will be a number that ranges from 1 to 6060. This way the starting number won't be constant: which would consequently result in the first random number request being very easily predictable. Having 6000+ possibilities as the start number is a decent number: any (still working and being used) computer processor can handle a number that size. Let's make this Seed based math have a maximum value of a wierd number such as 84,312 so the total characters of the number never exceeds 5 to make the speed of math calculations extremely fast but also so the seed will continually be 'resized', making the process of reverse engineering this generator a lot harder... From here, every single random number request will have the following formula applied to the seed where s is the current seed and n is the new seed, and remember this is just my crap example so you understand this: n = ((s^2)+"Seconds"). if n is greater than the cap value (82312) then n = n - 82312. If right now is 16 minutes and 39 seconds, then the starting seed would be 1640. Then, the secondary cap would need to be applied to the next time this used: n^2. Lets give this secondary cap a wierd number of (2471).. I'll go into more detail how this would be applied to a random number function later on.

During my own experience working with random number generators I have found some pretty interesting ways other programmers have come up with to make random numbers almost impossible to break. I won't go into any more detail about these, just wanted to share how there are other ways to go about generating random numbers.

User Input

When the user browses a website that needs to generate random numbers, the site records their mouse movement and stores it when they leave the page they are on. It stores the X,Y coordinates as well as the DateTime of each mouse movement, essentially making it possible to recreate the mouse movements in real time if they actually wanted to. How this applies is that you could take "DateTime"+"X"+"Y" and use that as a number. This would be similar to Clock Based method but with the additional 'security' of 2 more variables.

Audio Based

Digitally preset as many online radio stations and/or local mp3s or other sound files that are in a digital medium, into an audio player. Stream this audio player to your sound analysis software. This software will turn the audio into number values, sometimes even bits depending on how much 'quality' you want to lose in the conversion, and then use the resulting number. The rate of conversion is as high as 100 new audio-based-numbers per second. The reason for having several preset sources of sound is so that the software can 'switch stations' every so many seconds as to make the source of audio unknown. To add to this even further, you could optionally mix 1-5 stations upon each 'station switch', (mozart+madonna=53?) making the audio garbled, but also making the conversion a little more secure, less predictable, in the event that someone wants to reverse engineer this.

Light Based

Optical equipment measures light emissions from trapped mercury atoms. Now that has got to be expensive.

Internet Based

If you're familiar with RSS feeds, site scraping, or other means of extracting external data from sites, content which the public really doesn't have any means of altering (www.yahoo.com's home page, RSS feed from multiple sites), anyhow take this 'pure text' of data that should change fairly regularly, and use some simple quick math equations (such as counting the total characters, total letter 't's, etc) to generate a Seed value.

Clock, Bit, Seed: It doesn't matter

Regardless of how the resulting number is generated, in almost all cases the last math applied to the resulting number is this function: If the min number is not 1 then apply the difference to the min and max to shift them correctly. Then, subtract the max number from the resulting number over and over until the (new, temporary) resulting number is less than the max number. If the remainder is zero then the random number created is the max number, otherwise the random number is what you came up with in the step before. Now, in actual math values with some examples... Lets say you want a random number between 4 and 13, including 4 and 13 as possible outcomes: Let's re-use the opening 3 examples

Preliminary

4 > 1, so (4-1)=3. (min=4, max=13) - 3... (min=1, max=10)

Clock Based

(11639) : 11639 vs 10: remainder: 9. (compensate min max variance of +3) end result = 12

Bit Based

(15277) : 15277 vs 10: remainder: 7. (compensate min max variance of +3) end result = 10

Seed Based

(1640) : [n = ((s^2)+"Seconds"))] (82312)(2471) [Right now is 16 minutes 39 seconds]
- 1640*1640=2689600, 2689600+39=2689639. 2689639 vs 82312 = 55655. 55655 vs 10 = 5.
(compensate min max variance of +3) end result = 8...
- apply the wierd number cap for the next seed: 55655 vs 2471 = 1293.. to show how the next seed would work, with another date stamp as well: The new DateTime is now 17 minutes 03 seconds.
- 1293*1293=1671849, 1671849+03=1671852. 1671852 vs 82312 = 25612. 25612 vs 10 = 2.
(compensate min max variance of +3) end result = 5...

Reusing the previous examples yet again, if I were a programmer needing to create a random number generator from scratch so a business could say 'we have our own unique methods of generating random numbers', such as an online casino, and I created a function called GetRand(min,max), and 'right now' is still the same time as it was in the examples... If my GetRand(min,max) function used the same clock based formulas as the example, GetRand(4,13) would equal 9. A bit based GetRand(4,13) would equal 7. A seed based GetRand(4,13) would equal 8. Seems pretty simple now huh? It better.

Breaking it down

Quite simply, everything prior to this was for you to understand the various ways random numbers are generated and how they aren't really random: They are based on a non-constant yet predictable variable, the time of day. The hard part is figuring out what techniques, methods, and math formulas have been applied to the time of day to generate these 'random' numbers. I'm going to expand upon some previous examples, making them slightly more complicated, while also using some practical examples as to how these can be applied.

Breaking it apart

Let's say I have been contracted to build a mini slot machine from my own hardware building and software programming skills. I choose to use a fairly old processor, one that can only handle about 7 or 8 random number requests per second, based on the GetRand(min,max) function I custom created. This fact is about all that matters for this scenario example: what other hardware peices are used, their speeds, wont have any affect.

Here is another pattern of numbers. Can you figure out the pattern?

I hope I have dumbed this down enough and simplified this enough to make it understandable how random numbers can be reversed engineered so long as you know the math formulas behind how they are generated in the first place. If you don't know the math, you can always just run some simulations and throw the results into a table and compare the values, such as their distance from eachother, etc. In the real world, as far as random numbers are concerned, there is usually much more sophisticated math being used and reverse engineering or hacking random number generators to take advantage of them is pretty hard to do.

If you've learned anything from this paper, I hope its that you now understand that you can not create something random from something constant, and that everything we perceive as random is usually just because as a human with a brain you can't instantly see a pattern and be able to predict the next number in the pattern, that almost everything perceived as random actually has a predictable semi-constant behind it that can be extracted thereby solving a chunk of the random-equation.