© 2024 The authors. This article is published by IIETA and is licensed under the CC BY 4.0 license (http://creativecommons.org/licenses/by/4.0/).
OPEN ACCESS
A cryptography algorithm for data transfer encryption provides confidentiality, requires considerable computing power, and is not commonly implemented in embedded systems with limited computing power, such as Programmable Logic Controller (PLC). PLC is the core component for automation and control in industrial automation. For decades, PLC has prioritized speed over security; program execution in PLC must be as efficient as possible. The cryptography algorithm uses a seed, the initialization vector, to encrypt the data with the cryptography key to strengthen the encryption. Pseudo Random Number Generator (PRNG) can be used as the initialization vector. This paper proposes the XORasm PRNG algorithm, the lightweight XORshiftbased algorithm with a modified seed from the system’s clock. The applied methodology generates and visualizes PRNG, tests the randomness, and implements the PRNG on compact PLC. XORasm is evaluated statistically with runstest in simulation by comparing the algorithm to one of the simulated compact PLC’s PRNG implementations. The findings from this research are that pvalues demonstrate that XORasm is statistically and significantly more random than the current implementation, and there is evidence that XORasm’s generated data distribution is practically random at a 99.95% confidence level, suitable for implementation in embedded systems as a lightweight PRNG.
embedded system, lightweight, PLC, PRNG, programmable logic controller, pseudorandom number generator, runstest, simulation
In Industrial Automation, Manufacturers of embedded systems like PLC design simple and very efficient algorithms [1]. Automation and control have existed for decades [2]. One of the earliest industrial automation papers was in “Cybernetics: or Control and Communication in the Animal and Machine” by Wiener, N. in 1948 [3]. There are four eras: 1. early control (before 1900), 2. preclassical (19001940), 3. classical (19351960), and 4. modern control (1995now). The Industrial Revolution was referenced in 1776 [4].
Since the 1970s, PLC [5, 6], the core automation component in industrial automation [7], has been the catalyst for revolutionizing the industrial transition from mechanical (Industry 2.0) to computerized (Industry 3.0) by replacing mechanical timers, counters, and relays with programmable equivalents.
As part of the embedded systems (a set of hardware and software with limited computing power and resources designed for a specific purpose [8]), there are some identified issues in PLC security [9]. As PLC prioritizes speed over security, for many years, security has been a significant concern [10]. Typical attacks exploit the PLCbased system’s vulnerabilities in the communication industry protocols. The payload attack is a key concern against data integrity in Industry 4.0, particularly in IT/OT integration [11]. Encryption is part of the confidentiality of cryptography, which protects data at rest or in transit. Without encryption, data is stored or transferred in plaintext [12, 13].
Cryptography algorithms depend on an initialization vector, a fixed value, or randomly generated by RNG for increased security [14]. The lack of implementation of RNG in embedded systems such as PLC makes it challenging to perform securityrelated functions, such as data encryption. The initialization vector is typically used as the seed for modern cryptography algorithms, AES, for example, the accepted standard of symmetric encryption [15, 16], widely adopted since weaknesses found in DES and 3DES [17].
Existing PLCs mostly run at 32 bits—thus, the addressing capacity is up to 2^{32} (4,294,967,296) locations. A 64bit PLC with an addressing capacity of up to 2^{64} locations is less likely to be needed. Older PLCs run at 8 or 16 bits.
RNG is commonly implemented as PRNG (usually softwarebased) [18, 19] rather than TRNG [20, 21], usually hardwarebased [2225]. PRNG is a trivial function in highlevel programming languages (e.g., Java or Python). There is also a hardware implementation [7]. In PLC, RNG is not usually part of the standard functionalities in the PLC’s common programming languages: LAD/LLD, ST/STX, SFC, or FB.
Stronger PRNG is possible (64 bits and above) for PC or PC Servers based on the XORshift algorithm (fast and lightweight) [26] and further explored in previous studies [27, 28]. However, PLCs, as embedded systems, commonly operate in 32 bits. While PRNG has been implemented using the system timer, the PRNG algorithm for generating better randomness for embedded systems such as PLCs is underexplored.
The research questions in this paper are RQ1: “Can we have a better PRNG algorithm for lightweight embedded systems?” RQ2: What is the base for measuring such an algorithm, and how can we measure such an algorithm for better randomness?” and RQ3: How can we apply the algorithm to embedded systems?”
The key theoretical contribution in this paper is the XORasm PRNG algorithm, the PRNGtype algorithm based on the XORshift algorithm, targeted for lightweight, lowpower computing systems with generated random numbers that are statistically proven and randomly distributed at a 99.95% significance level. The main practical contribution is that XORasm can be used as the PRNG for lightweight, lowpower computing power embedded systems. This is demonstrated through experiments on the actual PLC.
Figure 1 illustrates the paper organization. It starts with the introduction, followed by the method and main results, and ends with the discussion and conclusion sections. The method consists of four stages: generating random numbers, visualizing the generated random numbers, testing for randomness, and practical implementation on the actual PLC.
Figure 1. Paper organization
Figure 2 illustrates the four stages to generate two different sets of random numbers. A: Generate two sets of random numbers with XORasm and LGF algorithms, B: Visualize the generated random numbers, C: Test with runstest in dieharder testing suite [29] to produce pvalues and analyze the randomness using pvalues, and D: Implement the XORasm on an embedded system (using FB, LAD, and ST programming language on a PLC). One implementation of RNG in PLC is in Siemens’ LGF.
2.1 Stage A – Random number generation
First, 32bit random numbers are generated with XORasm– simulated in a laptop rather than in PLC due to constrained resources. Second, 32bit random numbers are also generated with a simulated Siemens LGF random function in the same laptop. In this stage within Figure 1, XORasm and simulated LGF random functions generate 2 to the power of 32 random numbers. This is written as pow (2, 32) in C language. The pow (base, exponent) is a function as part of the math library. With 4 Bytes for each random number (32 bits equals 4 Bytes), the 2^{32} random numbers stored in disk space are 4 Bytes times 4,294,967,296, which equals 17,179,869,184 Bytes (16GB). Therefore, two datasets of four billion random numbers, with a size of 4 Bytes for each random number, totaling 16GB per file, are generated. Those two datasets are treated as two different independent distributions.
Figure 3 illustrates the pseudocode for generating seed for XORshift. On the right is the pseudocode of XORshift (run multiple times). In combination, the code is called XORasm. The seed is generated by computing the nanosecond portion of system time and storing it in 32 bits as unsigned integers. XOR operation with log_{2}(2^{32}) is performed on each Byte of the system time. For the 32 bits, the system time is XORed with the constant 0x05050505 (0x represents the following values in hexadecimal), which enhances randomness. The seed, representing the initial value of the XORshift algorithm, is stored in a file for reproducibility.
Figure 2. Method for generating, visualizing, and testing random numbers
Figure 3. Xorasm pseudocode
2.2 Stage B  Visualizing the generated random numbers
Figure 4 illustrates the normalized distribution of the first 10,000 generated random numbers for the XORasm. Figure 5 illustrates the normalized distribution of the first 10,000 generated random numbers for the simulated LGF random function. Both are used by dieharder for testing. Please refer to stage B in Figure 2.
Figure 4. Normalized distribution (XORasm)
Figure 5. Normalized distribution (simulated LGF)
Normalized distribution means the chart does not directly visualize the random numbers, as the 32 bits of generated random numbers are too big for the chart to handle. Using Python programming, the generated random numbers are first normalized to be within the 0.0 to 1.0 (0100%) range by dividing the random numbers by 232 – 1, the highest random numbers produced in 32 bits. This is step one. The result is then mapped to a certain range for plotting purposes and, in this case, mapped to minimum = 0 to maximum = 10,000. The normalized generated random numbers for visualization are minimum + results_from_step_one * (maximum – minimum). Therefore, 0 + results_from_step_one * (10,000  0) becomes results_from_step_one * 10,000. This is for the yaxis. The xaxis is a sequence of 32 bits of unsigned integer numbers ranging from 0 to 10,000.
2.3 Stage C  Testing for randomness and technique for statistical randomness testing
2.3.1 Testing for randomness
Dieharder tests the data generated from the XORasm and the simulated LGF random function using a customdeveloped Linux shell script for each sample size. Each time it executes, it performs two runstests. Thus, for five runstests for each sample size, the script generates ten pvalues and ten assessments. Please refer to stage C in Figure 2. The pseudocode for the LGF random function is illustrated below. First, the function exchanges Byte 3 and 0 of the generated system’s time (nanosecond part). Then, Byte 2 and Byte 1 are swapped.
The dieharder processes the generated random numbers. The following options were used to run the dieharder, selecting only necessary tests. “d test_number” is set to run only the intended test for randomness. “t sample_size” is set for taking the sample_size from the filename, how many random numbers that we want to test. “p psample” is set for how many times we want to run the test to generate the pvalue. “f filename” is the file name containing the binary sequence of 32 bits generated random numbers, 4 Bytes each ($dieharder d test_number t sample_size p psample f filename).
For the 32bit XORasm algorithm, XORasm32 algorithm, the following command runs dieharder from the Linux shell:
“$dieharder d 15 t 10000 p 100 f xorasm32_data.bin.”
Options are set: “d 15 option” to run only the runstest for randomness, “t 10000” to generate ten thousand random numbers with 4 Bytes each (32 bits). “f filename” is the file name containing the binary sequence of 32 bits numbers (4 Bytes each), in this case, filename: xorasm32_data.bin.
2.3.2 Techniques for statistical randomness testing
The pvalues output from dieharder is used for statistical tests. The pvalue for testing randomness has the following conditions: Null Hypothesis (H_{0}) and Alternate Hypothesis (H_{1}). H_{0} = Data is random. H_{1} = Data is not random.
By using alpha = 0.005 (0.5% confidence level) as set by default in dieharder, the decision will be as follows (equivalent to the assessment in the dieharder test result):
If pvalue <= alpha, then we reject the Null Hypothesis. At (1alpha) confidence level, we believe the evidence shows that the data is statistically significant and not random. There is a chance, at pvalue, that the data is random.
Figure 6. Experiment setup
If pvalue > alpha, we fail to reject the Null Hypothesis. At (1alpha) confidence level, we believe the evidence shows that the data is random (statistically insignificant).
2.4 Stage D  Practical implementation on the embedded system, a PLC
We apply XORasm to an embedded system, the Siemens 1200 Compact PLC. SCL includes a callable function that implements the XORasm. The initial seed (32bit unsigned doubleword) is derived from the nanoseconds portion of the PLC’s system time. FB is called from the LLD program, which resides within the main program block. The main program transmits a signal to industrialgrade lamps, switching ON or OFF randomly.
Figure 6 illustrates the experiment setup in which a Siemens Simatic S71200 PLC runs the compiled program driving four industrialgrade lamps: White, green, yellow, and red. The industrialgrade lamps act as the actuator and are configured to connect to the PLC’s digital outputs, the PLC DO ports. In the illustration, the yellow lamp is in the ON state, as the current value from the program output, as shown on the laptop’s monitor, is x48 (in hexadecimal, translated to 72 in decimal). The output 72 is between 51 and 75, including 51 and 75, in which the programmed condition triggers the yellow lamp to an ON state. When a lamp is in the ON state, all other lamps are set to the OFF state.
Figure 7 illustrates the pseudocode of the simulated LGF random function.
A 24VDC power supply powered the PLC, the Siemens SITOP PSU 100S, which sources power from the regular 220VAC. In this setup, the voltages for all digital inputs and outputs are 24VDC.
Table 1 lists the values range and the corresponding lamps the program switches ON. Figures 8 and 9 illustrate the pseudocode of the XORasm algorithm (generating the initial seed and the main function, respectively), and Figure 10 illustrates the pseudocode of the PLC main program.
Figure 7. Pseudocode (simulated LGF random function)
Table 1. Values range and lamps to switch ON

Industrialgrade Lamps 


White 
Green 
Yellow 
Red 
025 
ON 
OFF 
OFF 
OFF 
2650 
OFF 
ON 
OFF 
OFF 
5175 
OFF 
OFF 
ON 
OFF 
76100 
OFF 
OFF 
OFF 
ON 
The laptop configuration includes an Intel i7 with 2.8GHz and 4 Cores processors, 16GB RAM, 1TB SSD storage, a Windows 11 OS, and Python version 3.19 with Anaconda. It also includes WSL2 with Ubuntu v22.00.04, a gcc compiler version 11.3.0, and the dieharder RNG testing suite version 3.31.1.
The source program was developed using the Siemens TIA Portal software application, version 17. The source program was compiled and downloaded to the PLC through an ethernet cable connecting the laptop to the PLC directly without an ethernet hub.
The PLC program starts when the green push button is pressed and stops when the red push button is pressed. The green and red push buttons are set as sensors and connected to the PLC’s digital inputs (DI ports).
Figure 8. Pseudocode (XORasm) – Inital seed
Figure 9. Pseudocode (XORasm) – Main function
Initially, all lamps are set to the OFF state by setting each of the DO ports connected to them to 0VDC (OFF state). To set the lamp to the ON state, the corresponding DO port is set to 24VDC. When the PLC program runs, Siemens TIA Portal software shows live realtime monitoring of realtime values. The TIA Portal Software is the digital twin of the real PLC hardware running the program.
Figure 10. Pseudocode (PLC program)
Table 2 summarizes the statistical analysis for both algorithms: The XORasm and LGF random function. The table lists the pvalues of the XORasm runs test’s simulation result compared to the pvalues of the simulated LGF random function for a sample size of 10,000 (dieharder’s default). The assessment is PASS if the pvalue > alpha (pvalue above 0.5%) and WEAK if the pvalue <= alpha.
The data distribution is random if the pvalue has a value above alpha. All pvalues are consistently above alpha. Therefore, all pvalues are statistically nonsignificant, meaning we fail to reject the Null Hypothesis.
For XORasm, all generated data are tested through runs test with pvalues above alpha. Therefore, we believe the evidence shows that the XORasm’s data distribution is random (statistically insignificant).
In contrast, for the simulated LGF random function, the pvalues have values below alpha several times. Three tests with pvalues 0.0001234, 0.00026679, and 0.00320486 are statistically significant, meaning we reject the Null Hypothesis for those pvalues. We accept the alternative hypothesis (data is not random for all pvalues below alpha). Therefore, we believe the evidence shows that the data distribution for the LGF random function is statistically significant and not random. There is a chance, at pvalue, that the data is random.
Table 2. XORasm runstest and LGF random function
Dieharder Testing Suite for Randomness (runs test)^{*2)} 

Runs Test^{*3)} for sample size: 10,000^{*1)} 

1 
2 
3 
4 
5 

1 
2 
1 
2 
1 
2 
1 
2 
1 
2 

A. XORasm algorithm 

 pvalue 
0.1086568 
0.0490162 
0.1226328 
0.0067232 
0.2227413 
0.2219964 
0.0298953 
0.0546924 
0.0931555 
0.2600096 
 assessment 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
B. Siemens PLC random algorithm^{*4)} 

 pvalue 
0.0001234 
0.7644705 
0.0002668 
0.0032049 
0.1014579 
0.7473626 
0.0161754 
0.1249053 
0.0533751 
0.0919376 
 assessment 
WEAK 
PASSED 
WEAK 
WEAK 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
PASSED 
^{*1)} dieharder default sample size. 

^{*2)} The filename for xorasm algorithm: "xorasm32_data.bin", and for simulated Siemens' PLC: "rndlgf_data.bin". 

The random numbers are taken from a .bin file. Number of generated random numbers in each .bin file: 4,294,967,295 Bytes. 

Each random number is 4 Bytes (32 bits). Thus, total file size is 16GB (Giga Bytes). 

^{*3)} Simulated and tested by the dieharder RNG testing suite on an x86 laptop. 

^{*4)} The Siemens PLC LGF random algorithm function simulated on an x86 laptop. 
Based on the pvalue results, statistically, we fail to reject the Null Hypothesis. We conclude that there is evidence that the data distribution generated by the XORasm PRNG algorithm is practically random at a 99.95% confidence level (Table 2).
In contrast, from the pvalues results for the LGF random function runstest, statistically, we conclude that there is evidence that data distribution generated from the LGF random function algorithm is not random at a 99.95% confidence level. Random function in Siemens PLC LGF represents the design and implementation of common random number algorithm in embedded systems. Provided the hardware supports it, a better random generator to increase randomness can use another system clock or independent timing cycle [30].
The assessment results conclude that for the default sample_size = 10,000 sets by the dieharder RNG testing suite, the XORasm has a better random number distribution as it passed all the tests (assessment = PASSED). In contrast, the simulated LGF random function has the result, assessment = WEAK, in three of the ten runs, indicating it does not have a good distribution of random numbers for all the tests.
The findings show that XORasm is a good PRNG, according to runstest performed in a dieharder testing suite.
The theoretical implication of this research is the contribution to the literature in Computer Science and Computer Engineering for embedded systems with lightweight, low computing power. The advantage for embedded devices is straightforward, as the XORasm PRNG algorithm is statistically proven and randomly distributed at a 99.95% significance level. While the algorithm is lightweight and suitable for embedded devices such as PLC, IoT, and edge computing devices, it provides better randomness over the random generator based on the system’s clock. XORasm can serve as the seed for modern encryption algorithms such as AES. Possible further research is by setting a lower alpha value and inspecting whether the test conclusion still holds.
The practical implication is that the XORasm PRNG algorithm can be used for lowpower computing devices such as PLC to increase data transfer security among embedded systems. Further research is possible using 64bit PLCs or combining embedded systems with higherpower devices, including PCs and servers.
This research paper proposes a lightweight, softwarebased PRNG called XORasm for embedded systems such as PLC, based on the XORshift algorithm, combined with a modified seed taken randomly from the PLC’s system clock. The randomness of the 32bit XORasm PRNG algorithm is demonstrated through a simulation using statistics (runstest) using the dieharder RNG testing suite. The result is statistically analyzed to the simulated Siemens implemented 32bit random function, LGF_RandomRange_Dint, as part of Siemens’ LGF. XORasm demonstrated in Siemens 1200 Compact PLC. This has answered RQ1: Yes, and RQ2: Taking one of the implementations in PLC as a base, the LGF in Siemens PLC, and using statistical runstests within the dieharder testing suite.
Based on the pvalues analysis, the findings demonstrated that XORasm is statistically and significantly better at generating randomness than the current implementation. Statistically, at a 99.95% confidence level, there is evidence that the generated data distribution is practically random and suitable for implementation as a lightweight PRNG for embedded systems.
XORasm uses the XORshift algorithm with the seed, the initialization vector. XORasm significantly improves the randomness of generated random numbers and is suitable for lightweight embedded systems like PLC. By comparing XORasm and the simulated Siemens PLC implementation, the LGF random function, the XORasm implementation in Siemens PLC, has answered RQ3.
The experiment shows that the 32bit version of the proposed XORasm successfully passed the dieharder RNG testing suite for runstest. XORasm is generally suited to 32bit PLCs and can be implemented using LLD, SFC, ST, or FB.
The XORasm PRNG algorithm (32 bits) is based on the XORshift algorithm. Its primary design purpose is to be fast and efficient for a lightweight system with limited computing power. The demonstrated implementation is limited to only one PLC, Siemens PLC.
This research’s practical implications may include enhancing existing random number generation algorithms for PLCs, not just Siemens, and low computing power embedded systems in general, including edge computing devices.
Potential future work for theoretical contribution may include improving the algorithm, making the PRNG more random using a different modified seed, and testing using a statistical runstest with lower alpha (lower than 0.5%), considering lightweight computing power and limited resources in embedded systems.
Potential future work on the practical application could involve applying the XORasm PRNG algorithm to several 32bit PLC brands, 16bit earlier PLCs, CPS, and possibly 64bit future PLCs. Using XORasm as a seed (initialization vector) for a symmetric cryptography algorithm (e.g., AES) in CBC mode, for example, can improve data transfer security between PLC and SCADA systems and other external systems such as MES or IoT.
3DES 
Triple DES 
AES 
Advanced Encryption Standard 
CBC 
Cipher Block Chaining 
CPS 
CyberPhysical Systems 
DES 
Data Encryption Standard 
DI 
Digital Input 
DO 
Digital Output 
FB 
Function Block 
GB 
Giga Bytes 
GHZ 
Giga Hertz 
IoT 
Internet of Things 
IT 
Information Technology 
LAD/LLD 
Ladder Logic Diagram 
LGF 
Library of Generic Functions (Siemens) 
LSB 
Least Significant Byte 
MES 
Manufacturing Execution System 
MSB 
Most Significant Byte 
OS 
Operating System 
OT 
Operational Technology 
PC 
Personal Computer 
PLC 
Programmable Logic Controller 
PRNG 
PseudoRNG 
PSU 100S 
Siemens Power Supply Unit, 100Stype 
RAM 
Random Access Memory 
RNG 
Random Number Generator 
RQ 
Research Question 
SCADA 
Supervisory Control and Data Acquisition 
SFC 
Sequential Function Chart 
SSD 
Solid State Drive 
ST/STX 
Structured Text 
TB 
Terabyte 
TIA 
Totally Integrated Automation 
TRNG 
True RNG 
VAC 
Voltage Alternating Current 
VDC 
Voltage Direct Current 
WSL2 
Windows Subsystem for Linux version 2 
XOR 
eXclusive OR bitwise operation 
[1] Tarnawski, J., Kudełka, P., Korzeniowski, M. (2022). Advanced control with PLC—Code generator for aMPC controller implementation and cooperation with external computational server for dealing with multidimensionality, constraints and LMI based robustness. IEEE Access, 10: 1059710617. https://doi.org/10.1109/ACCESS.2022.3142054
[2] Cheng, F.T. (2021). Evolution of automation and development strategy of intelligent manufacturing with zero defects. In: Cheng, F.T. (e.d.) Industry 4.1: Intelligent Manufacturing with Zero Defects. IEEE Press, New York, USA, pp. 123. https://doi.org/10.1002/9781119739920.CH1
[3] Bennett, S. (1996). A brief history of automatic control. IEEE Control Systems Magazine, 16(3): 1725. https://doi.org/10.1109/37.506394
[4] Smith, A. (1997). An Inquiry into the Nature and Causes of the Wealth of Nations. University of Chicago Press, Chicago, USA. https://doi.org/10.7208/chicago/9780226763750.001.0001
[5] Zaheer, M.A., Nauman, M., Fai, R.B. (2022). Identify components to manage security requirements in RAMI 4.0: An explanatory case study on industrial architecture. Advances in Automobile Engineering, 11(2): 17. https://doi.org/10.35248/21677670.1000186
[6] Luo, J., Kang, M., Bisse, E., Veldink, M., Okunev, D., Kolb, S., Canedo, A. (2020). A quadredundant PLC architecture for cyberresilient industrial control systems. IEEE Embedded Systems Letters, 13(4): 218221. https://doi.org//10.1109/LES.2020.3011309
[7] Namekar, S.A., Yadav, R. (2020). Programmable Logic Controller (PLC) and its applications. International Journal of Innovative Research in TechnologY (IJIRT), 6(11): 372376.
[8] Grycel, J.T., Walls, R.J. (2019). A random number generator built from repurposed hardware in embedded systems. ArXiv. https://doi.org/10.48550/arXiv.1903.09365
[9] Wu, H., Geng, Y., Liu, K., Liu, W. (2019). Research on programmable logic controller security. IOP Conference Series: Materials Science and Engineering, 569(4): 042031. https://doi.org/10.1088/1757899X/569/4/042031
[10] Buchanan, S.S. (2022). Cyberattacks to industrial control systems since Stuxnet: A systematic review. Ph.D. Dissertation. Capitol Technology University, South Laurel, Maryland, USA. https://doi.org/10.5555/AAI29163646
[11] Wang, Z., Zhang, Y., Chen, Y., Liu, H., Wang, B., Wang, C. (2023). A survey on programmable logic controller vulnerabilities, attacks, detections, and forensics. Processes, 11(3): 918. https://doi.org/10.3390/PR11030918
[12] NIST. (2024). The NIST Cybersecurity Framework (CSF) 2.0. https://doi.org/10.6028/NIST.CSWP.29
[13] Stouffer, K., Pease, M., Tang, C.Y., Zimmerman, T., Pillitteri, V., Lightman, S., Hahn, A., Saravia, S., Sherule, A., Thompson, M. (2023). Guide to operational technology (OT) security. NIST Special Publication SP 80082r3, Gaithersburg, Maryland. https://doi.org/10.6028/NIST.SP.80082r3
[14] KarellAlbo, J.A., LegónPérez, C.M., MadarroCapó, E.J., Rojas, O., SosaGómez, G. (2020). Measuring independence between statistical randomness tests by mutual information. Entropy, 22(7): 741. https://doi.org/10.3390/E22070741
[15] Mammeri, Z.Z. (2024). Cryptography: Algorithms, Protocols, and Standards for Computer Security. John Wiley & Sons, Inc., Hoboken, New Jersey, USA. https://doi.org/10.1002/9781394207510
[16] Rastoceanu, F., Rughiniş, R., Tranca, D.C. (2023). Lightweight cryptographic secure random number generator for IoT devices. In 2023 24th International Conference on Control Systems and Computer Science (CSCS), Bucharest, Romania, pp. 180185. https://doi.org/10.1109/CSCS59211.2023.00036
[17] Dworkin, M.J., Barker, E., Nechvatal, J.R., Foti, J., Bassham, L.E., Roback, E., Dray Jr., J.F. (2023). Advanced Encryption Standard (AES) (FIPS 197). Federal Information Processing Standards Publication, National Institute of Standards and Technology, Gaithersburg, Maryland. https://doi.org/10.6028/NIST.FIPS.197upd1
[18] Parisot, A., Bento, L.M.S., Machado, R.C.S. (2021). Testing and selecting lightweight pseudorandom number generators for IoT devices. In 2021 IEEE International Workshop on Metrology for Industry 4.0 & IoT (MetroInd4.0&IoT), Rome, Italy, pp. 715720. https://doi.org/10.1109/MetroInd4.0IoT51437.2021.9488454
[19] Rukhin, A., Soto, J., Nechvatal, J., Smid, M., Barker, E., Leigh, S., Levenson, M., Vangel, M., Banks, D., Heckert, A., Dray, J., Vo, S. (2010). A statistical test suite for random and pseudorandom number generators for cryptographic applications. NIST Special Publication 80022 Revision 1a, Gaithersburg, Maryland. https://doi.org/10.6028/NIST.SP.80022r1a
[20] Gomez, H., Arenas, J., Roa, E. (2020). Lowcost TRNG IPs. IET Circuits, Devices & Systems, 14(7): 942946. https://doi.org/10.1049/ietcds.2019.0535
[21] AlShidaifat, A., Jayawickrama, C., Jung, Y., Song, H., Kahrama, N. (2020). Chaotic true random number generator for secure communication applications. In 2020 International SoC Design Conference (ISOCC), Yeosu, Korea (South), pp. 244245. https://doi.org/10.1109/ISOCC50952.2020.9333113
[22] Boyd, R. (1999). Random number generator. In: Tolerance Analysis of Electronic Circuits Using MATHCAD. CRC Press, Boca Raton, USA, p. 76. https://doi.org/10.1201/978131521540227
[23] Nebhen, J. (2020). A low power CMOS variable true random number generator for LDPC decoders. In: Goel, N., Hasan, S., Kalaichelvi, V. (eds) Modelling, Simulation and Intelligent Computing: Proceedings of MoSICom 2020. Lecture Notes in Electrical Engineering, vol 659. Springer, Singapore. https://doi.org/10.1007/9789811547751_53
[24] Jofre, M., Curty, M., Steinlechner, F., Anzolin, G., Torres, J.P., Mitchell, M.W., Pruneri, V. (2011). True random numbers from amplified quantum vacuum. Optics Express, 19(21): 2066520672. https://doi.org/10.1364/OE.19.020665
[25] Matsuoka, S., Ichikawa, S., Fujieda, N. (2021). A true random number generator that utilizes thermal noise in a programmable systemonchip (PSoC). International Journal of Circuit Theory and Applications, 49(10): 33543367. https://doi.org/10.1002/cta.3046
[26] Marsaglia, G. (2003). XORshift RNGs. Journal of Statistical Software, 8(14): 16. https://doi.org/10.18637/jss.v008.i14
[27] Bhattacharjee, K., Das, S. (2022). A search for good pseudorandom number generators: Survey and empirical studies. Computer Science Review, 45: 100471. https://doi.org/10.1016/J.COSREV.2022.100471
[28] Vigna, S. (2016). An experimental exploration of Marsaglia's XORshift generators, scrambled. ACM Transactions on Mathematical Software (TOMS), 42(4): 123. https://doi.org/10.1145/2845077
[29] Brown, R.G. (2023). Robert G. Brown’s General Tools Page. Available: https://webhome.phy.duke.edu/~rgb/General/dieharder.php.
[30] BIN95 (2023). A universal PLC programming example of how to generate a truer exponential random number. Available: https://bin95.com/articles/automation/plcprogrammingrandom.htm/.