Random Sequence Ⅰ

Random numbers

Now we are learning about random numbers.

Random numbers are a sequence of numbers that appear to have no pattern and are unpredictable. In computer science and mathematics, the generation of random numbers is typically divided into two types: true random numbers and pseudo-random numbers.

True Random Numbers: True random numbers are obtained by measuring the unpredictability of physical processes. Here are some methods for obtaining true random numbers:

  1. Environmental Noise: Utilizing noise in the environment, such as thermal noise in electronic devices, radioactive decay events, etc.

  2. Hardware Devices: Using hardware devices, such as quantum random number generators, leveraging uncertainty in quantum physics.

  3. Natural Events: Utilizing natural events, such as atmospheric noise, lightning, etc. While true random numbers are theoretically completely random, obtaining and using them is comparatively expensive and inconvenient. In practical applications, due to convenience and performance considerations, pseudo-random numbers are typically used.

Pseudo-Random Numbers: Pseudo-random numbers are generated by algorithms, and although they appear random, they are predictable. Pseudo-random numbers are generated through a deterministic process, and their generation depends on a seed value.

  1. Pseudo-Random Number Generator (PRNG): PRNG is an algorithm used to generate pseudo-random numbers. It takes a seed value and then generates a seemingly random number sequence through a series of mathematical operations. Since PRNG is deterministic, the same seed value will produce the same random number sequence.

  2. Seed Value: The seed value is crucial in pseudo-random number generation. The same seed value will generate the same random number sequence, so the choice of the seed value needs to be sufficiently random and unpredictable.

  3. Periodicity: Since pseudo-random numbers are generated by deterministic algorithms, they often repeat within a certain period. This is known as the period of the pseudo-random number generator. A shorter period may pose security issues because if an attacker can determine or predict the state of the random number generator, they can infer future random numbers. In cryptography, the security of pseudo-random numbers is crucial. If the algorithm or seed value of a pseudo-random number generator is predictable, it may lead to vulnerabilities in cryptographic systems, such as easily breakable keys or hash values. Therefore, random number generators in cryptography need to be carefully designed and tested to ensure they have sufficient security. In cryptography, random numbers play a crucial role because cryptographic algorithms often require some level of randomness to enhance security. Applications of random numbers in cryptography include key generation, initialization vectors (IV), salts, etc.

Key Aspects of Random Numbers in Cryptography:

  1. Random Number Generator (RNG): Random numbers in cryptography need to be generated by a random number generator. RNG is an algorithm that generates a seemingly random number sequence. In cryptography, these number sequences are often referred to as pseudo-random numbers because they are generated by deterministic algorithms but exhibit properties similar to true random numbers.

  2. True Random Numbers vs. Pseudo-Random Numbers: True random numbers are obtained by measuring unpredictable events in natural processes, such as radioactive decay or atmospheric noise. However, acquiring true random numbers can be expensive and inconvenient. In contrast, pseudo-random numbers are generated by algorithms that accept a seed value and generate a seemingly random number sequence based on this seed value. In cryptography, pseudo-random numbers are typically secure enough, but ensuring the randomness of the seed is crucial.

  3. Seed Value: The seed value plays a critical role in random number generation. The same seed value will produce the same random number sequence. In cryptography, ensuring that the seed is sufficiently random and unpredictable is essential. Typically, systems use true random events (such as mouse movements or keyboard strokes) as seed values to enhance the unpredictability of generated pseudo-random numbers.

  4. Cryptographic Applications:

    • Key Generation: Random numbers are used for generating keys in symmetric encryption algorithms. Strong keys are vital for the security of the system.

    • Initialization Vector (IV): In some encryption algorithms, especially in block cipher modes, randomly generated initialization vectors enhance the strength and security of encryption.

    • Salt: In cryptographic hash functions, randomly generated salts are combined with passwords to prevent rainbow table attacks.

  5. Security Considerations: If the random number generator is not secure, it may lead to vulnerabilities in cryptographic systems. For example, if the generator's seed is predictable, attackers may be able to predict the generated random numbers, compromising keys or password hashes. In summary, random numbers in cryptography are a crucial component for ensuring system security. Therefore, the design and use of random number generators require careful consideration to ensure security. The quality of a random number sequence is often measured by its uniformity and independence. Both of these characteristics are vital for the applications of random numbers and the security of cryptography. Let's first look at Uniformity: A good random number generator should produce numbers within its range to ensure that the probability of each possible output value is equal. If random numbers are unevenly distributed within a range, certain values may appear more frequently than others, leading to imbalance or unfairness in a system. In cryptography, uniformity is crucial for generating strong passwords, randomly selecting encryption keys, and more.

import random

def generate_uniform_binary_sequence(size):
    # Generate a binary sequence of specified size using a loop, with each element being a randomly generated 0 or 1
    return [random.randint(0, 1) for _ in range(size)]

# Specify the size of the sequence
sequence_size = 10

# Generate a uniformly distributed binary sequence
binary_sequence = generate_uniform_binary_sequence(sequence_size)

# Print the generated binary sequence
print("Binary Sequence:", binary_sequence)

This code utilizes the random module in Python to generate a binary sequence of a specified size with a uniform distribution. Here's a breakdown:

  • import random: Import the random module in Python, which provides functions for generating pseudo-random numbers.

  • def generate_uniform_binary_sequence(size):: Define a function called generate_uniform_binary_sequence. This function takes a parameter, size, indicating the desired size of the binary sequence.

  • return [random.randint(0, 1) for _ in range(size)]: Use a list comprehension to generate a list containing 'size' elements. Each element is a randomly generated integer (0 or 1) within the closed interval [0, 1]. This achieves the functionality of generating a uniformly distributed binary sequence.

  • sequence_size = 10: Specify the size of the binary sequence to be generated, set here as 10.

  • binary_sequence = generate_uniform_binary_sequence(sequence_size): Call the previously defined function to generate a binary sequence with a uniform distribution containing 10 elements.

  • print("Binary Sequence:", binary_sequence): Print the generated binary sequence.

In summary, this code uses the random module in Python to generate a binary sequence of a specified size with a uniform distribution and then prints the result. Such uniformly distributed binary sequence generation can be useful in certain contexts, such as in simulation experiments or randomized algorithms.

Indepence

Let's delve into the concept of independence: Random numbers should be mutually independent, meaning that a generated random number should not reveal information about other random numbers. If there is a dependency between random numbers, an attacker might be able to predict subsequent values by observing partial sequences, compromising the randomness of the system. In cryptography, independence is crucial for preventing attackers from using statistical methods to guess passwords or keys.

The definition of independence in a random sequence is relatively complex because, in practical applications, it's challenging to completely satisfy the condition that "no subsequence can be derived from other subsequences." Typically, we achieve "pseudo-random" sequences by using random number generators instead of true randomness.

In Python, you can use various functions from the random module to generate pseudo-random sequences. These sequences are termed "pseudo-random" because they are generated by algorithms rather than true random processes. A simple example is using the random.random() function to generate pseudo-random floating-point numbers uniformly distributed between 0 and 1.

# Import the random module
import random

# Define a function to generate an independent pseudo-random sequence
def generate_independent_sequence(size):
    # Use list comprehension to generate a list of pseudo-random floating-point numbers between 0 and 1
    return [random.random() for _ in range(size)]

# Specify the size of the sequence
sequence_size = 10

# Generate an independent pseudo-random sequence using the defined function
independent_sequence = generate_independent_sequence(sequence_size)

# Print the result
print("Independent Sequence:", independent_sequence)

This code utilizes the random module in Python to generate an independent pseudo-random sequence of a specified size. Let's analyze the code in detail:

  • import random: Import the random module in Python, which provides functions for generating pseudo-random numbers.

  • def generate_independent_sequence(size):: Define a function called generate_independent_sequence. This function takes a parameter, size, indicating the desired size of the pseudo-random sequence.

  • return [random.random() for _ in range(size)]: Use a list comprehension to generate a list containing 'size' elements. Each element is a pseudo-random floating-point number generated within the open interval [0.0, 1.0). The random.random() function returns a floating-point number with a value range of [0.0, 1.0).

  • sequence_size = 10: Specify the size of the pseudo-random sequence to be generated, set here as 10.

  • independent_sequence = generate_independent_sequence(sequence_size): Call the previously defined function to generate an independent pseudo-random sequence containing 10 elements.

  • print("Independent Sequence:", independent_sequence): Print the generated independent pseudo-random sequence.

In summary, this code generates an independent pseudo-random sequence of a specified size, where each element is a randomly generated floating-point number within the range [0.0, 1.0). Such sequences can be useful in certain simulations, probability modeling, and scenarios requiring a uniform distribution.

Note that the term "independence" here refers to the fact that, when using a specific random number generator, each element in the sequence is independently generated. However, due to being pseudo-random, theoretically, there might be some patterns or correlations. If true independence is crucial, more sophisticated random number generation methods, such as cryptographically secure random number generators or hardware random numbers, may be required.

Unpredictability

Additionally, there is a requirement for the unpredictability of random numbers.

The unpredictability of random numbers refers to the inability to accurately predict their values before they are generated. In the fields of cryptography and security, unpredictability is a crucial attribute because predictable random numbers may lead to vulnerabilities, making the system susceptible to attacks.

Unpredictability of True Random Numbers: True random numbers are obtained by measuring unpredictable events in natural processes, such as radioactive decay, atmospheric noise, and so on. Since these events themselves are unpredictable, true random numbers are theoretically unpredictable. However, obtaining true random numbers is often more expensive and less convenient.

Unpredictability of Pseudo-Random Numbers: Pseudo-random numbers are generated by algorithms, and their unpredictability depends on the quality of the generation algorithm and the choice of seed values. If the generation algorithm is robust and the seed values are sufficiently random, the generated pseudo-random numbers can exhibit high unpredictability in practice. However, if the algorithm or seed values are predictable, attackers might deduce the generated random numbers.

The Importance of Seed Values: Pseudo-random number generators typically require an initial seed value to start. If the seed value is predictable, the output of the generator becomes predictable. Therefore, choosing sufficiently random and unpredictable seed values is crucial to ensuring unpredictability. Often, systems strive to use true randomness events from the external environment as seed values, such as user mouse movements, keyboard inputs, and so on.

Applications in Cryptography: In cryptography, unpredictability is crucial for generating keys, initializing vectors, salts, etc. If attackers can predict these random numbers, it may be possible to infer the internal mechanisms of the encryption system, thereby compromising security.

In summary, the unpredictability of random numbers is one of the fundamental requirements for ensuring the security of cryptographic systems. In practical applications, it is necessary to ensure that the generated random numbers are statistically unpredictable through careful selection and testing of random number generators, the use of sufficiently random seed values, and other means to enhance system security.

# Import the secrets module
import secrets

# Define a function to generate an unpredictable sequence of random numbers
def generate_unpredictable_sequence(size):
    # Use list comprehension to generate a list of random 8-bit integers
    return [secrets.randbits(8) for _ in range(size)]

# Specify the size of the sequence
sequence_size = 10

# Generate an unpredictable random sequence using the defined function
unpredictable_sequence = generate_unpredictable_sequence(sequence_size)

# Print the result
print("Unpredictable Sequence:", unpredictable_sequence)

For random sequences that require unpredictability, the use of the secrets module is typically more appropriate than the random module. The secrets module provides functions for generating high-quality random numbers, with a focus on security and unpredictability.

This code snippet uses the secrets module in Python to generate an unpredictable random sequence of a specified size. Let's analyze the code in detail:

  • import secrets: Import the secrets module in Python, which provides functions for generating secure random numbers. The secrets module is specifically designed for cryptographic and security applications, offering a more secure method for generating random numbers compared to the random module.

  • def generate_unpredictable_sequence(size):: Define a function called generate_unpredictable_sequence. This function takes a parameter, size, indicating the desired size of the unpredictable random sequence.

  • return [secrets.randbits(8) for _ in range(size)]: Use a list comprehension to generate a list containing 'size' elements. Each element is an 8-bit random integer generated by calling secrets.randbits(8). The secrets.randbits(8) function returns an 8-bit (1-byte) random integer, with each bit being unpredictable.

  • sequence_size = 10: Specify the size of the unpredictable random sequence to be generated, set here as 10.

  • unpredictable_sequence = generate_unpredictable_sequence(sequence_size): Call the previously defined function to generate an unpredictable random sequence containing 10 elements.

  • print("Unpredictable Sequence:", unpredictable_sequence): Print the generated unpredictable random sequence.

In summary, this code uses the secrets module to generate an unpredictable random sequence of a specified size. Because the secrets module focuses on providing more secure random number generation, the generated random numbers have higher reliability in cryptographic and security applications. Such sequences are often used in cryptography for generating keys, initializing vectors, and other scenarios where a high level of unpredictability is crucial.

TRNG

TRNG (True Random Number Generator) is an abbreviation for True Random Number Generator. It is a device designed to generate true random numbers by measuring physical randomness events in natural processes. Unlike Pseudo-Random Number Generators (PRNG), TRNG does not depend on algorithms but instead exploits the unpredictability inherent in physical processes to achieve genuine randomness.

Working Principle:

  1. Physical Processes: The core idea of TRNG is to generate random numbers by measuring the unpredictability of physical events in natural processes. These events can include phenomena such as thermal noise, random charge movements in electronic devices, radioactive decay, and more. These events are uncontrollable and unpredictable physical phenomena in the real world, providing genuine randomness.

  2. Sensors: TRNG typically requires sensors to monitor physical changes in natural processes. The outputs of these sensors are collected and used to generate random numbers.

  3. Signal Processing: By processing the outputs of sensors, TRNG can extract randomness. This may involve steps such as noise filtering, nonlinear transformations, and other processing steps to ensure the extracted random numbers possess high-quality randomness.

Features and Advantages:

  1. True Randomness: The random numbers generated by TRNG are truly random and do not depend on algorithmic inputs or seeds. This makes TRNG particularly useful in cryptography and other secure applications because they are less susceptible to predictive attacks.

  2. High Security: Due to not being constrained by algorithms, TRNG is typically more resistant to attacks. For critical security applications, especially those requiring high unpredictability, the use of TRNG can provide enhanced security.

Application Areas:

  1. Cryptography: A typical application of TRNG is in cryptography, where highly random numbers are needed for generating encryption keys, initialization vectors, and other cryptographic purposes.

  2. Security Tokens: In authentication and access control, TRNG can be used to generate secure tokens and one-time passwords.

  3. Simulation Experiments: In fields such as simulation experiments and mathematical modeling, high-quality random numbers are required to simulate the unpredictability of the real world.

In summary, TRNG is a powerful random number generator that provides genuine randomness by harnessing the physical randomness in natural processes. In applications where security requirements are high, TRNG is often an ideal choice.

# Import the secrets module
import secrets

# Define a function to generate an unpredictable sequence of random numbers using secrets module
def generate_unpredictable_sequence(size):
    # Use list comprehension to generate a list of 8-bit random integers
    return [secrets.randbits(8) for _ in range(size)]

# Specify the size of the sequence
sequence_size = 10

# Generate an unpredictable random sequence using the defined function
unpredictable_sequence = generate_unpredictable_sequence(sequence_size)

# Print the result
print("Unpredictable Sequence:", unpredictable_sequence)

# Import the os module
import os

# Define a function to generate a TRNG sequence using /dev/random
def generate_trng_sequence(size):
    # Read TRNG data from /dev/random
    trng_data = open("/dev/random", "rb").read(size)
    return list(trng_data)

# Specify the size of the sequence
sequence_size = 10

# Generate a TRNG sequence using the defined function
trng_sequence = generate_trng_sequence(sequence_size)

# Print the result
print("TRNG Sequence:", trng_sequence)

This piece of code utilizes the os module in Python along with the /dev/random device of the operating system to generate a True Random Number Generator (TRNG) sequence.

  • The generate_trng_sequence(size) function: This function opens the /dev/random device, reads the specified number of bytes from the device in binary mode (rb), and converts it into a list of integers.

  • /dev/random device: In Unix-like systems, /dev/random is a device file representing a True Random Number Generator (TRNG). It relies on physical processes such as environmental noise and hardware events to provide high-quality randomness. Reading from /dev/random may block until the device determines that sufficient entropy is available to generate true random numbers.

  • sequence_size = 10: Specifies the size of the TRNG sequence to be generated, set to 10 here.

  • trng_sequence = generate_trng_sequence(sequence_size): Calls the previously defined function to generate a TRNG sequence containing 10 bytes.

  • print("TRNG Sequence:", trng_sequence): Prints the generated TRNG sequence. Result: This code generates a TRNG sequence, with the result stored in trng_sequence and printed using the print statement. Since the /dev/random device is used, this sequence consists of true random numbers, and its randomness is not dependent on any algorithm but is based on real random events in physical processes, such as environmental noise. It's worth noting that reading from /dev/random may block, as the system requires sufficient entropy to generate true random numbers. If blocking is undesirable in the application scenario, consider using /dev/urandom, which is a non-blocking version of /dev/random. However, /dev/urandom uses a pseudo-random number generation algorithm and enhances its quality with a true random number seed.

PRNG

PRNG (Pseudo-Random Number Generator) is the abbreviation for pseudo-random number generator. It is a sequence generated by a deterministic algorithm that appears random but is actually predictable. PRNG uses an initial value, typically referred to as a seed, as input to the algorithm, thereby producing a sequence of numbers. In comparison to True Random Number Generators (TRNG), PRNG is simpler and more efficient in implementation, but its randomness depends on the choice of the seed and the quality of the algorithm.

Operation Principle:

  1. Initial Seed: PRNG requires an initial seed as input. Using the same seed will result in the generation of the same sequence, making seed selection crucial. Developers typically aim to use values with sufficient randomness, such as current time, user input, etc.

  2. Deterministic Algorithm: PRNG utilizes a deterministic algorithm that generates a sequence based on the seed value. This algorithm is repeatable, meaning the output is predictable as long as the input remains the same.

  3. Periodicity: The sequences generated by PRNG are typically periodic, meaning that after a certain length of the sequence, the generator will restart and produce the same sequence again. The length of this cycle depends on the algorithm of the generator and the choice of seed.

Characteristics and Advantages:

  1. Efficiency: PRNG is generally more efficient than TRNG as they are algorithmically generated and do not rely on measurements of physical processes.

  2. Predictability: PRNG is predictable, which can be advantageous in certain applications. Reproducing the same random number sequence with the same seed facilitates debugging and testing.

  3. Applicability: PRNG is suitable for most scenarios requiring pseudo-random numbers, such as simulation experiments, algorithm design, game development, etc.

Application Areas:

  1. Simulation Experiments: In scientific research and engineering, PRNG is used to simulate experiments and generate data with a certain level of randomness.

  2. Algorithm Design: In algorithm design, PRNG is often employed to generate random test data, validating the performance and robustness of algorithms.

  3. Game Development: In game development, PRNG is used to generate random maps, enemy behaviors, game events, etc.

  4. Encryption: In some non-security-critical contexts, PRNG can also be used to generate encryption keys and initialization vectors.

In summary, PRNG is a widely used random number generator. Although the sequences it generates are theoretically predictable, they generally meet the requirements of most practical applications. In situations where security is of utmost importance, a preference may lean towards using True Random Number Generators (TRNG).

import random

def generate_prng_sequence(size):
    random.seed()  # Use the current system time as the seed
    return [random.randint(0, 255) for _ in range(size)]

# Specify the sequence size
sequence_size = 10

# Generate PRNG sequence
prng_sequence = generate_prng_sequence(sequence_size)

# Print the result
print("PRNG Sequence:", prng_sequence)

This code utilizes the random module in Python to generate a pseudo-random number sequence, employing a Pseudo-Random Number Generator (PRNG).

  • The generate_prng_sequence(size) function: This function uses random.seed() to set the seed of the PRNG. If no seed is provided, the random module defaults to using the current system time as the seed. It then generates a list containing size elements using a list comprehension, where each element is an integer between 0 and 255 generated by random.randint(0, 255).

  • random.seed(): This function is used to initialize the seed of the PRNG. Here, since no seed parameter is provided, the current system time is used as the seed. This ensures that a different random sequence is obtained each time the program is run.

  • sequence_size = 10: Specifies the size of the PRNG sequence to be generated, set to 10 here.

  • prng_sequence = generate_prng_sequence(sequence_size): Calls the previously defined function to generate a sequence of 10 pseudo-random numbers.

  • print("PRNG Sequence:", prng_sequence): Prints the generated PRNG sequence.

Result: This code generates a pseudo-random number sequence, with the result stored in prng_sequence and printed using the print statement. Since random.seed() is used with the current system time as the seed, a different pseudo-random number sequence is obtained each time the program is run. It's important to note that pseudo-random numbers are generated through algorithms, so in certain security-sensitive scenarios requiring high randomness, this approach may not be suitable.

import random

def generate_prng_sequence(size, seed):
    random.seed(seed)
    return [random.randint(0, 255) for _ in range(size)]

# Specify sequence size and seed
sequence_size = 10
seed_value = 42

# Generate reproducible PRNG sequence
prng_sequence = generate_prng_sequence(sequence_size, seed_value)

# Print the result
print("Reproducible PRNG Sequence:", prng_sequence)

This code uses the random module in Python to generate a pseudo-random number sequence. Unlike the previous example, a seed value is introduced here, allowing the generated random sequence to be repeated under the same seed value.

The function generate_prng_sequence(size, seed): This function uses random.seed(seed) to set the seed of the pseudo-random number generator. This ensures that every time a random function from the random module is called, the same random number sequence will be obtained. It generates a list containing size elements using list comprehension, where each element is an integer between 0 and 255 generated by random.randint(0, 255).

random.seed(seed): This function is used to initialize the seed of the pseudo-random number generator. Here, the user can provide a seed value (seed) for generating a reproducible random number sequence.

sequence_size = 10 and seed_value = 42: These values respectively specify the size of the PRNG sequence to be generated and the seed value for the pseudo-random number generator.

prng_sequence = generate_prng_sequence(sequence_size, seed_value): This line calls the previously defined function to generate a reproducible sequence containing 10 pseudo-random numbers.

print("Reproducible PRNG Sequence:", prng_sequence): This line prints the generated reproducible PRNG sequence.

Result: This code generates a pseudo-random number sequence, storing the result in prng_sequence and printing it using the print statement. Since the seed value (seed_value) is set, the same pseudo-random number sequence will be obtained every time the program is run. This functionality is useful in scenarios where reproducing the same random number sequence under specific conditions is essential, such as in experiments, simulations, and other applications that require reproducibility.

PRF

PRF（Pseudo-Random Function）is a type of pseudo-random function commonly used in cryptography and secure protocols. PRF simulates the behavior of a true random function but is actually generated by a deterministic algorithm, hence the term pseudo-random function.

Characteristics and Properties:

  1. Deterministic: PRF is a deterministic function, meaning that given the same input and key, it always produces the same output. This is different from true random functions, where the output is unpredictable.

  2. Pseudo-Randomness: Despite being generated by a deterministic algorithm, PRF exhibits pseudo-randomness on its output, appearing similar to the behavior of a true random function. This pseudo-randomness is introduced through the key, so using different keys with the same input will result in different outputs.

Applications:

  1. Cryptography and Encryption: PRF is widely used in cryptographic protocols and encryption algorithms. In encryption algorithms, PRF is employed to generate pseudo-random numbers, produce key streams, or derive new keys.

  2. Security Protocols: Security protocols, such as SSL/TLS, use PRF to generate key material. During the key negotiation process, PRF ensures that the generated keys are difficult for attackers to predict.

  3. Pseudo-Random Number Generators (PRNG): PRF can serve as the foundation for pseudo-random number generators. Through appropriate parameterization, PRF can generate pseudo-random number sequences that meet specific requirements.

Security Considerations:

  1. Key Length: The security of PRF typically depends on the length of the key. Longer key lengths enhance the security of PRF, making it more resistant to attacks like exhaustive search.

  2. Resistance to Analysis: PRF should exhibit a certain level of resistance to various cryptographic analysis attacks, such as differential attacks and linear attacks.

  3. Key Update: Regularly updating keys is a method to maintain the security of PRF. Outdated keys may expose PRF to certain attacks, such as birthday attacks.

import hmac
import hashlib

def prf(key, message, hash_algorithm=hashlib.sha256):
    # Calculate the PRF value using HMAC with the specified hash algorithm
    return hmac.new(key, message.encode('utf-8'), hash_algorithm).digest()

# Specify the secret key and input message
secret_key = b"secret_key"
input_message = "Hello, PRF!"

# Calculate the PRF value
prf_value = prf(secret_key, input_message)

# Print the result
print("PRF Value:", prf_value.hex())  # Display the hexadecimal representation of the PRF value

This code implements a simple example of a Pseudo-Random Function (PRF) using the hmac and hashlib modules in Python.

  • prf Function: This function utilizes the HMAC (Hash-based Message Authentication Code) algorithm as the PRF. It takes three parameters: the key, the message, and the hash_algorithm, with a default value of SHA-256. The function returns the computed PRF value.

  • hmac.new(key, msg, digestmod): hmac.new is a function provided by the hmac module to create a new HMAC object. It takes a key, a message, and a digestmod (digest module) as parameters. Here, the key is the secret key, msg is the encoded message, and digestmod is the hash algorithm, defaulting to SHA-256.

  • digest(): This method returns the binary digest value of the HMAC object, which is the output of the PRF.

  • secret_key = b"secret_key": Specifies a key for the PRF, represented as a byte string.

  • input_message = "Hello, PRF!": Specifies the message for which the PRF is to be calculated, represented as a string.

  • prf_value = prf(secret_key, input_message): Calls the prf function to calculate the PRF value, storing the result in prf_value.

  • print("PRF Value:", prf_value.hex()): Prints the hexadecimal representation of the computed PRF value.

Result: This code demonstrates how to implement a PRF using the HMAC algorithm. In practical applications, different hash algorithms and keys can be chosen based on specific requirements. PRFs are commonly used in cryptographic protocols to generate key material, providing controlled pseudo-randomness with security and predictability.

Reference

1. https://medium.com/asecuritysite-when-bob-met-alice/is-your-number-really-random-35f56cf40d9b

2. https://www.researchgate.net/figure/Basic-True-Random-Number-Generator-TRNG-block-diagram_fig8_334006319

3. https://pit-claudel.fr/clement/blog/how-random-is-pseudo-random-testing-pseudo-random-number-generators-and-measuring-randomness/

4. https://medium.com/asecuritysite-when-bob-met-alice/we-give-away-too-many-of-our-digital-secrets-heres-verifiable-oblivious-pseudorandom-functions-13ba5f78380f

PreviousSymmetric Cryptosystem ⅢNextRandom Sequence Ⅱ

Last updated