How to generate transparent random numbers using blockchain

Much scientific work has focused on the generation of random numbers as well as the distribution of said random numbers for use as a cryptographic key. However, emphasis is often placed on one of the two to the exclusion of the other, but both are often simultaneously important. Here we present a simple hybrid free-space link scheme for both the generation and secure distribution of (pseudo-)random numbers between two remote parties, drawing the randomness from the stochastic nature of atmospheric turbulence. The atmosphere is simulated using digital micro-mirror devices for efficient, all-digital control. After outlining one potential algorithm for extracting random numbers based on finding the centre-of-mass (COM) of turbulent beam intensity profiles, the statistics of our experimental COM measurements is studied and found to agree well with the literature. After implementing the scheme in the laboratory, Alice and Bob are able to establish a string of correlated random bits with an 84% fidelity. Finally, we make a simple modification to the original setup in an attempt to thwart the hacking attempts of an eavesdropper, Eve, who has access to the free-space portion of the link. We find that the fidelity between Eve’s key and that of Alice/Bob is 54%, only slightly above the theoretical minimum. Atmospheric turbulence could hence be leveraged as an added security measure, rather than being seen as a drawback.

Monte Carlo (MC) method is widely used in resolving mathematical problems that are too complicated to solve analytically. The method involves with sampling process of the random numbers and probability to estimate the result. As MC method depending on a large number of good quality random numbers to produce a high accuracy result, developing a good random number generator (RNG) is vital. Most of random number generators are developed in software based, with the improvement of Field Programmable Gate Arrays (FPGA) density and speed in recent days, implementing random number generator (RNG) directly into hardware is feasible. Random Walk on the Boundary (WOB) is one of MC methods that applied to calculate the unit cube capacitance. The unique requirement of this method is the random numbers produced by RNG must fall within the Gaussian distribution and the maximum decimal values in the range of [0, 1]. Thus, in this paper we presented a novel hardware RNG for Random WOB method to calculate unit cube capacitance in FPGA. The RNG is implemented in floating-point base, using the combination of Cellular Automata Shift Register (CASR) and Linear Feedback Shift Register (LFSR) then channeled through Box-Muller transformation. There is linear approximation in computing logarithmic function applied in Box-Muller transformation. Based on statistical tests, the random numbers generated is nearly 97.5% resembling the standard normal distribution.

Random number generators are integral components to Monte Carlo codes. They provide the pseudorandom number sequence used to actually sample the distributions of interest. As a result, they are one of the most important components to the software. The current recommended MCNP random number generator is a 63-bit linear congruential generator (LCG). This generator is quite fast, but it has some drawbacks. First, it only has a period of 2⁶³. Due to the necessarily non-optimal usage of random numbers to ensure parallel reproducibility, this amount is too few to guarantee random number sequences are not reused in all configurations the code runs under. As simulation size increases, users will need to be aware of the limitations of the generator and tune configuration variables to best suit their simulations, or they will need to assume that reuse is not negatively affecting their answers. Neither of these are optimal. Second, small LCGs are fairly weak in bit generation quality, and this can have an unknown impact on the quality of the simulation. This paper is an investigation into whether or not more modern random number generators can supersede the current ones. The goal is to find a generator that is similar or superior in speed to the LCGs, has a state space large enough to make strong guarantees about random number reuse, and passes all modern random number test suites. If such a generator is found, it would eliminate the need for the user to even be aware of the limitations of the random number generator and would simplify the use of the code. This paper will be broken into several parts. Sec. 2 will discuss the evolution of the random number generator within the MCNP code. Sec. 3 will go over what a Monte Carlo code needs from a generator to be reproducible and portable and how the current generator behaves in that light. Sec. 4 goes through how each generator was tested. Finally, Sec. 5 will discuss improvements that could be made to the code.

Random number generation is a fundamental aspect of computer science, cryptography, simulations, and statistical sampling. This paper explores the definitions, classifications, and implementations of random and pseudo-random number generators (RNGs and PRNGs). We examine true random number generators (TRNGs), which derive randomness from physical phenomena, and pseudo-random number generators (PRNGs), which use deterministic algorithms to produce sequences that mimic randomness. Case studies, including Random.org, HotBits, laser-based RNGs, and the Linux random number generator, illustrate practical implementations. We also discuss vulnerabilities, security considerations, and the importance of entropy in generating unpredictable sequences.

RNGAVXLIB: Program library for random number generation, AVX realization

Random numbers are needed in many areas: cryptography, Monte Carlo computation and simulation, industrial testing and labeling, hazard games, gambling, etc. Our assumption has been that random numbers cannot be computed; because digital computers operate deterministically, they cannot produce random numbers. Instead, random numbers are best obtained using physical (true) random number generators (TRNG), which operate by measuring a well-controlled and specially prepared physical process. Randomness of a TRNG can be precisely, scientifically characterized and measured. Especially valuable are the information-theoretic provable random number generators (RNGs), which, at the state of the art, seem to be possible only by exploiting randomness inherent to certain quantum systems. On the other hand, current industry standards dictate the use of RNGs based on free-running oscillators (FRO) whose randomness is derived from electronic noise present in logic circuits and which cannot be strictly proven as uniformly random, but offer easier technological realization. The FRO approach is currently used in 3rd- and 4th-generation FPGA and ASIC hardware, unsuitable for realization of quantum RNGs. In this chapter we compare weak and strong aspects of the two approaches. Finally, we discuss several examples where use of a true RNG is critical and show how it can significantly improve security of cryptographic systems, and discuss industrial and research challenges that prevent widespread use of TRNGs.

The importance of random number generators (RNGs) to various computing applications is well understood. To ensure a quality level of output, high-entropy sources should be utilized as input. However, the algorithms used have not yet fully evolved to utilize newer technology. Even the Android pseudo RNG (APRNG) merely builds atop the Linux RNG to produce random numbers. This paper presents an exploratory study into methods of generating random numbers on sensor-equipped mobile and Internet of Things devices. We first perform a data collection study across 37 Android devices to determine two things-how much random data is consumed by modern devices, and which sensors are capable of producing sufficiently random data. We use the results of our analysis to create an experimental framework called SensoRNG, which serves as a prototype to test the efficacy of a sensor-based RNG. SensoRNG employs collection of data from on-board sensors and combines them via a lightweight mixing algorithm to produce random numbers. We evaluate SensoRNG with the National Institute of Standards and Technology statistical testing suite and demonstrate that a sensor-based RNG can provide high quality random numbers with only little additional overhead.

In this paper, a novel method for obtaining the random numbers utilizing astronomical data is proposed. The method uses two different algorithms for generation of random numbers sequence. Astronomical data collected from the scientific study of the universe, especially of the relative motions, relative positions of astronomical objects are utilized in our algorithms. The first algorithm uses a particular astronomical object in a fixed position for the random number generation. The random sequence is obtained from the relative positions of other astronomical objects with reference to the selected object. The second algorithm selects any diverse astronomical object as a reference in a varying mode for computation of the relative positions of different objects with that reference to generate the random number stream. Both algorithms use mathematical equations for computing the next jump or hop to the other astronomical object. The generated random numbers obtained from the two algorithms are tested with a standard statistical test suite including, frequency test, run test, random binary matrix rank test, complexity test, universal test and entropy test. The results obtained from the statistical tests of the two algorithms are compared with the other publicly available random number generation techniques, like, linear congruential and modular exponentiation. The preliminary results show that the algorithms perform well. The random numbers generated by our method has sufficient period and unpredictability that makes them suitable for consideration as encryption keys in symmetric cryptography.

CHAPTER 12 - SIMULATIONS WITH RANDOM NUMBERS

Today, cryptographic security depends primarily on having strong keys and keeping them secret. The keys should be produced by a reliable and robust to external manipulations generators of random numbers. To hamper different attacks, the generators should be implemented in the same chip as a cryptographic system using random numbers. It forces a designer to create a random number generator purely digitally. Unfortunately, the obtained sequences are biased and do not pass many statistical tests. Therefore an output of the random number generator has to be subjected to a transformation called post-processing. In this paper the hash function SHA-256 as post-processing of bits produced by a combined random bit generator using jitter observed in ring oscillators (ROs) is proposed. All components – the random number generator and the SHA-256, are implemented in a single Field Programmable Gate Array (FPGA). We expect that the proposed solution, implemented in the same FPGA together with a cryptographic system, is more attack-resistant owing to many sources of randomness with significantly different nominal frequencies.

We present a new way of testing Random Number Generators (RNGs). Our approach allows to test Pseudo Random Number Generators (PRNGs) including Cryptographically Secure Pseudo Random Number Generators (CSPRNGs). The paper describes how to use machine learning for this. To construct a tester we compare the properties of three most common learning techniques to find the one most suitable one for testing RNGs. By analyzing the system during training and regarding the expected behavior of random numbers, we define an optimizer for learning RNGs. Based on the results and regarding the behavior of the machine learning algorithm, we define a rating for RNGs. On a state-of-the-art GPU cluster, we evaluate the full tester for multiple PRNGs. Additionally, we compare the results with the results from the commonly used test suite dieharder. The results prove that the developed tester is suitable for testing random numbers. In comparison to dieharder, it is even more powerful and able to replace it. Our tester could disclose weaknesses in PRNGs that are wrongly considered as CSPRNG. This could increase the security of many cryptographic protocols based on random numbers.

We present a generator producing unique and truly random bit sequences based on the measurement of the quantum uncertainty of a continuous variable vacuum state. Vacuum states have the advantage of being inherently pure states, i.e. they cannot be tempered with by an adversary and are easily detectable. Therefore, they are an ideal resource for a quantum RNG. Our RNG consists of a simple homodyne detection system.

Random number generators (RNG) are a fundamental hardware component in modern cryptographic systems [1]. The generation of random numbers can be subdivided into two classes, pseudo-RNGs and hardware RNGs. In pseudo-RNGs software algorithms are implemented on deterministic hardware but are dependent on a set of initial values or “seed”, which reduces the security. In contrast, hardware RNGs generate random numbers from a naturally occurring physical phenomenon, such as thermal noise. However, implementations often suffer from large silicon footprints due to the need to create resistor-amplifier-ADC chains [2] or bias removal circuits [3]. In this work, we experimentally demonstrate a compact and scalable 1T1R based RNG by harnessing the inherent stochasticity in the insulator-to-metal phase transition (IMT) in vanadium dioxide (VO 2 ).

This study investigates how qubits of modern quantum annealers (QA) such as D-Wave can be applied for generating truly random numbers. We show how a QA can be initialised and how the annealing schedule can be set so that after the annealing, thousands of truly random binary numbers are measured in parallel. Those can then be converted to uniformly distributed natural or real numbers in desired ranges, either biased or unbiased. We discuss the observed qubits’ properties and their influence on the random number generation and consider various physical factors that influence the performance of our generator, i.e., digital-to-analogue quantisation errors, flux errors, temperature errors and spin bath polarisation. The numbers generated by the proposed algorithm successfully pass various tests on randomness from the NIST test suite. Our source code and large sets of truly random numbers are publicly available on our project web page <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><uri>https://4dqv.mpi-inf.mpg.de/QRNG/</uri></monospace> .

In a functional program, a simple random number generator may generate a lazy list of random numbers. This is fine when the random numbers are consumed sequentially at a single point in the program. However, things are more complicated in a program where random numbers are used at many locations, such as in a large simulation. The programmer should not need to worry about providing separate generators with a unique seed at each point where random numbers are used. At the same time, the programmer should not need to coordinate the use of a single stream of random numbers in many parts of the program, which can be particularly difficult with lazy evaluation or parallel processing. We discuss several techniques for distributing random numbers to various parts of a program, and some methods of allowing different program components to evaluate random numbers locally. We then propose a new approach in which a random number sequence can be split at a random point to produce a pair of random number sequences that can be used independently at different points in the computation. The approach can also be used in distributed procedural programs, where it is desirable to avoid dealing with a single source of random numbers. The approach has the added advantage of producing repeatable results, as might be needed in debugging, for example.