Shell instances seven methods of generating random numbers

I. Problems
     Sometimes it is necessary to use a random number under the shell, and here is a summary of the method of generating a random number. What a computer generates is just a "pseudo-random number", it does not produce an absolute random number (it is an ideal random number). Pseudo-random numbers do not necessarily remain unique when reproduced in large numbers, but a good pseudo-random generation algorithm will produce a very long, non-repeating sequence.

Second, random numbers, seven methods to generate random numbers
(1) Via the internal system variable ($ RANDOM)

echo $ RANDOM

Generate an integer random number between 0 and 32767. If it exceeds 5 digits, you can add a fixed 10 digit integer and then perform the remainder.

Generate random numbers from 400,000 to 500,000:

 

[cpp] view plaincopy
#! / bin / bash
    
function rand () {
    min = $ 1
    max = $ (($ 2- $ min + 1))
    num = $ (($ RANDOM + 1000000000)) #Increase a 10-digit number and find the remainder
    echo $ (($ num% $ max + $ min))
}
    
rnd = $ (rand 400000 500000)
echo $ rnd
    
exit 0
(2) Random function using awk

 awk ‘BEGIN {srand (); print rand () * 1000000}’ #You can add if judgment, 779644

(3) openssl rand generates random numbers

openssl rand is used to generate random characters of the specified length bytes. -base64 or -hex Base64 encode a random string or display it in hex format.

openssl rand -base64 8 | md5sum | cut -c1-8 #A combination of eight letters and numbers, 3a61800e

openssl rand -base64 8 | cksum | cut -c1-8 # eight-digit number, 10784736

(4) Obtain a random number (date) by time

date +% s% N #Generate 19 digits, 1287764807051101270

date +% s% N | cut -c6-13 #take eight digits, 21793709

date +% s% N | md5sum | head -c 8 #A combination of eight letters and numbers, 87022fda

Generate random numbers from 1 to 50:

 

[cpp] view plaincopy
#! / bin / bash
    
function rand () {
    min = $ 1
    max = $ (($ 2- $ min + 1))
    num = $ (date +% s% N)
    echo $ (($ num% $ max + $ min))
}
    
rnd = $ (rand 1 50)
echo $ rnd
    
exit 0
(5) Generate random numbers from the unique data in the system (/ dev / random and / dev / urandom)

/ dev / random stores real-time data of the environment in which the system is currently running, which can be considered as the unique value data of the system at some time, providing high-quality random numbers.

/ dev / urandom is a non-blocking random number generator. It does not generate blocking when reading. It is a faster and less secure random number generator.

cat / dev / urandom | head -n 10 | md5sum | head -c 10 # 32f1e953ac

cat / dev / urandom | strings -n 8 | head -n 1 #Generate a random string of all characters, 08? WU $ ZU

cat / dev / urandom | sed -e ‘s / [^ a-zA-Z0-9] // g’ | strings -n 8 | head -n 1 #Generate a random string of numbers and letters, Ql2q9CXS

Where strings -n sets the number of characters in the string, and head -n sets the number of lines to output.

head-200 / dev / urandom | cksum | cut-d "" -f1 # urandom's data is much slower using cat. Here, read 200 lines using head, cksum will read the file content to generate unique integer data, cut with "" and then get the first field data

(6) Read the uuid code of Linux

       The full name of the UUID code is a Universally Unique Identifier (UUID). The UUID format is: Contains 32 hexadecimal digits. It is divided into five segments by a "-" connection number. The format is 8-4-4-4-12. 32 characters. Linux uuid code is also provided by the kernel, in the file / proc / sys / kernel / random / uuid. cat / proc / sys / kernel / random / uuid will get different data each time.

       cat / proc / sys / kernel / random / uuid | cksum | cut -f1 -d "" #Get different random integers, 1675034933

       cat / proc / sys / kernel / random / uuid | md5sum | cut -c1-8 #Number plus letter random number, d69a7ebf

Use linux uuid to generate 100 ~ 500 random numbers:

 

[cpp] view plaincopy
#! / bin / bash
    
function rand () {
    min = $ 1
    max = $ (($ 2- $ min + 1))
    num = $ (cat / proc / sys / kernel / random / uuid | cksum | awk -F ‘‘ ‘{print $ 1}’)
    echo $ (($ num% $ max + $ min))
}
    
rnd = $ (rand 100 500)
echo $ rnd
    
exit 0
(7) Randomly drawn from the element pool

pool = (a b c d e f g h i j k l m n o p q r s t 1 2 3 4 5 6 7 8 9 10)

num = $ {# pool [*]}

result = $ {pool [$ ((RANDOM% num))]}

It is used to generate a string of numbers and letters of a certain length. The elements in the string are from a custom pool.

 

[cpp] view plaincopy
#! / bin / bash
length = 8
i = 1
  
seq = (0 1 2 3 4 5 6 7 8 9 a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
  
num_seq = $ {# seq [@]}
  
while ["$ i" -le "$ length"]
do
 seqrand [$ i] = $ {seq [$ ((RANDOM% num_seq))]}
 let "i = i + 1"
done
  
echo "The random string is:"
for j in $ {seqrand [@]}
do
 echo -n $ j
done
echo
2. Random number application
(1) Random numbers are widely used in the Internet, such as computer simulation, data encryption, online games, etc. When logging in to certain forums or games, the system will generate a picture composed of random numbers and letters. Users must enter correctly Is a good way to prevent malicious attacks, because it is more difficult to crack the characters in the picture format. The key technology is to generate random numbers, and then use tools such as ASP.NET to package these strings into image formats for verification images.

(2) In online games, random numbers are often used to complete some functions, such as rolling dice and playing cards. The following is a roll of 1000 dice in a row, and then count the number of 1 to 6 points:

 

[cpp] view plaincopy
#! / bin / bash
  
#RANDOM = $$
  
PIPS = 6
MAX = 1000
throw = 1
  
one = 0
two = 0
three = 0
four = 0
five = 0
six = 0
  
count ()
{
case "$ 1" in
 0) let "one = one + 1" ;;
 1) let "two = two + 1" ;;
 2) let "three = three + 1" ;;
 3) let "four = four + 1" ;;
 4) let "five = five + 1" ;;
 5) let "six = six + 1" ;;
esac
}
  
while ["$ throw" -le "$ MAX"]
do
  let "dice = RANDOM% $ PIPS"
  count $ dice
  let "throw = throw + 1"
done
  
echo "The statistics results are as follows:"
echo "one = $ one"
echo "two = $ two"
echo "three = $ three"
echo "four = $ four"
echo "five = $ five"
echo "six = $ six"
The random number generated by RANDOM basically fluctuates around the average (ie, the variance is small).

(3) Create 10 system accounts in batches with random passwords

First look at the script that specifies the user password:

[cpp] view plaincopy
#! / bin / bash
#Create 10 system accounts in batches and set passwords, and the accounts and passwords are the same
for name in `seq -w 10`
do
    # Non-interactive input password
    useradd linux $ name && echo "linux $ name" | passwd --stdin linux $ name
done
The ten user names and passwords are all the same from linux-01 to linux-10, and then look at the script that the user password randomly generates:

 

[cpp] view plaincopy
#! / bin / bash
#Create 10 system accounts in batches and set passwords
rm -f user.log
for name in `seq -w 10`
do
    # Non-interactive input of random password
    password = `echo $ RANDOM | md5sum | cut -c1-8`
    # 可用 password = `echo" date $ RANDOM "| md5sum | cut -c3-11`
    #You can also use password = `penssl rand -base64 8 | md5sum | cut -c1-8`
    useradd linux $ name && echo password | passwd --stdin linux $ name
    echo -e "user = linux $ name \ t passwd = $ password" >> user.log #save username and password for review
done
The comparison shows that the flexibility and confidentiality of randomly generated passwords allows the administrator to open the user.log file and record the information of the ten users just created.

Summary
(1) The shell generates a pseudo-random number function $ RANDOM, which can easily generate a more evenly distributed pseudo-random number, which can meet the needs of most applications.

(2) There are still many methods for generating random numbers and they can be expanded. Only by expanding ideas can we choose the nearest method.

(Transfer) seven methods of shell examples to generate random numbers