Random numbers in linux

Guide to Generate Random Numbers in Linux

In Linux, you can generate random numbers using the random or urandom files in the /dev directory, which are special files that generate random data. To generate a random number between 0 and 32767, you can use the command echo $ ((RANDOM)). To generate a random number within a specific range, you can use the command echo $ ((RANDOM%range+min)), where range is the size of the range and min is the minimum value of the range.

Another way to generate random numbers in Linux is using the openssl command. The command openssl rand -base64 6 will generate a random base64 encoded string of 6 bytes which can be used as a random number.

You can also use the /dev/random or /dev/urandom special files in a script or program to generate random numbers. For example, in a C program you can use the function int rand(void); to generate a random number.

It is important to note that the random number generated by /dev/random may be less random than the one generated by /dev/urandom, but it is more secure.

Pseudorandom Number Generator

A pseudorandom number generator (PRNG) is a mathematical function that generates a sequence of numbers that appears to be random, but is actually determined by an initial value called a seed. The seed value is used to initialize the PRNG, and the same seed will always produce the same sequence of numbers.

PRNGs are often used in computer programs, simulations, and cryptography because they can quickly generate a large number of random numbers. However, because the sequence of numbers produced by a PRNG is determined by the seed, it is not truly random.

There are several types of PRNGs, including linear congruential generators, Lagged Fibonacci generators, and Mersenne Twister. Each of these algorithms uses different mathematical formulas to generate the numbers, and they have different properties in terms of the randomness and period of the generated numbers.

It is important to note that the quality of a PRNG can be measured by the randomness and period of the generated numbers, the security of the seed and the algorithm, and the statistical properties of the generated numbers.

In practice, pseudorandom numbers generated by a good PRNG are sufficient for most purposes, but in cryptographic or security-sensitive applications, true random numbers generated by physical processes such as radioactive decay or thermal noise are preferred.

$ RANDOM in Bash

In Bash, the $ RANDOM variable is a built-in variable that generates a random number between 0 and 32767. It can be used in a variety of ways to generate random numbers.

For example, the command echo $ RANDOM will output a random number between 0 and 32767. To generate a random number within a specific range, you can use the command echo $ ((RANDOM % range + min)), where range is the size of the range and min is the minimum value of the range.

You can also use $ RANDOM in scripts and programs to generate random numbers. For example, in a Bash script, you can use the command rand= $ RANDOM to generate a random number and store it in the variable rand.

It is important to note that the $ RANDOM variable generates pseudo-random numbers, and not true random numbers. And also $ RANDOM is not cryptographically secure, so it should not be used for cryptographic purposes.

In summary, $ RANDOM is a built-in variable in Bash that generates a random number between 0 and 32767, it can be used to generate random numbers in a variety of ways, but it should not be used for cryptographic purposes.

Using Awk

In awk, you can use the rand() function to generate a random number between 0 and 1. For example, the command awk ‘BEGIN ‘ will output a random number between 0 and 1.

You can also use the int() function to generate a random number within a specific range. For example, the command awk ‘BEGIN ‘ will output a random number between 0 and 9.

You can also use awk to generate random numbers and store them in a variable. For example, the command rand = int(rand() * 100) will generate a random number between 0 and 99 and store it in the variable rand.

It’s important to note that the rand() function in awk also generates pseudo-random numbers, which are determined by the seed value. If you want to use true random numbers, you can use the command awk ‘BEGIN’ to set the seed value to the current time.

In summary, awk provides the rand() function to generate random numbers between 0 and 1, which can be used in combination with other functions to generate random numbers within a specific range, and you can also store them in variables.

Using Pseudodevice Files

In Linux, you can generate random numbers using the special files /dev/random and /dev/urandom which are provided by the kernel. These files generate random data, and can be read like any other file.

The /dev/random file generates random data using a cryptographically secure algorithm, which makes it suitable for cryptographic purposes. However, it blocks when it runs out of entropy (the randomness gathered from the environment) and it can cause the program to halt until more entropy is gathered.

The /dev/urandom file also generates random data, but it does not block when it runs out of entropy. This makes it suitable for non-cryptographic purposes and for applications that need a high-volume of random numbers.

You can use the cat command to read from these files and generate a random number. For example, the command cat /dev/random | tr -dc ‘0-9’ | head -c 4 will output a random number of 4 digits.

You can also use these files in a script or program to generate random numbers. For example, in a C program you can use the function int read(int fd, void *buf, int count); to read a specified number of bytes from the file into a buffer, and then use the buffer as a random numbers.

In summary, the special files /dev/random and /dev/urandom in Linux can be used to generate random numbers, /dev/random is suitable for cryptographic purposes because it uses a cryptographically secure algorithm, while /dev/urandom is suitable for non-cryptographic purposes and for applications that need a high-volume of random numbers.

Conclusion

There are several ways to generate random numbers in Linux. The $ RANDOM variable in Bash and the rand() function in awk are built-in functions that generate pseudo-random numbers. The openssl rand command can also be used to generate random numbers. The special files /dev/random and /dev/urandom in the /dev directory can also be used to generate random numbers. However, it is important to note that these methods generate pseudo-random numbers, not truly random numbers. In cryptographic or security-sensitive applications, true random numbers generated by physical processes such as radioactive decay or thermal noise are preferred.

Источник

How to Generate Random Numbers in Linux

When it comes to the numbers game, no operating system does it better than Linux. Moreover, Linux operating system’s environment is smoothly transparent in its approach. So why would you need to generate random numbers in Linux?

The answer is pretty simple. With the numerous possibility of projects that can be run under Linux, a random-number generator is a must-have skill. For instance, users might be required to key in a unique sequence of characters to authenticate a particular app-related transaction.

The same users might require an application to generate a random and unique password string for them. Also, for a normal Linux user, a random number generator can help create unique file names especially if this user is actively involved in Linux file management.

This article will walk us through various ways of generating random numbers in a Linux operating system.

1. Generate Random Numbers Using shuf Command

As per its manual page, shuf can be used to generate random permutations. The standard syntax for the shuf command is as follows:

• -i is for the input range.
• MIN is for the minimum range.
• MAX is for the maximum range.
• -n is for the head count.
• COUNT is for the random number counts e.g 5, 7, 10, etc.

For instance, if we want 12 random numbers in the range of 1000 to 10,000, our shuf command implementation will look like the following:

By increasing the MIN and MAX range, the width of the generated random number will also increase.

$ shuf -i 100000-1000000 -n 12

2. Print Random Numbers Using /dev/urandom File

The Linux operating system has a file called /dev/urandom that basically performs pseudorandom number generation.

We can point this file to other Linux commands to produce random numbers. However, the command we choose to couple with this file should make it easy to specify the range of the random number we wish to generate.

In this case, we can couple the /dev/urandom file with the tr command and then pipe the result to the head command which will specify the length of the random number to be generated.

The tr command only looks for digits in the /dev/urandom file and deletes other characters before piping its result to the head command which counts and prints a random number with 13 digits.

3. Create Random Numbers Using RANDOM Variable

The Linux shell can generate a random number through a variable called RANDOM. This variable holds a range of numbers between 0 and 32767. Therefore, reading this variable will each time generate a unique random number.

For instance, let us create a bash script that generates a random number by reading the RANDOM variable.

Add the following code to the file.

#!/bin/bash #LinuxShellTips Script to Generate a Random Number RANDOM=$$ for i in RANDOM do echo $RANDOM done

Make the bash script executable and run it.

$ chmod u+x RandNumGen.sh $ ./RandNumGen.sh

Every time we run the script, a new random number will be generated.

Know of other cool ways to generate random numbers in Linux? Don’t forget to leave a comment.

Источник