Xorshift random number generators from primitive polynomials

TL;DR

This paper introduces algorithms to construct full period xorshift RNGs from primitive polynomials, identifies weaknesses in existing RNGs, and proposes improvements along with a new recursive matrix method for better linear complexity.

Contribution

It presents novel algorithms for creating full period xorshift RNGs from primitive polynomials and introduces a tweaked recursive matrix method with enhanced linear complexity.

Findings

Identified weaknesses in existing xorshift RNGs.

Developed algorithms for constructing full period RNGs.

Proposed an improved recursive matrix method.

Abstract

A class of xorshift random number generators (RNGs) are introduced by Marsaglia. We have proposed an algorithm which constructs a full period xorshift RNG from a given primitive polynomial. It is shown there is a weakness present in those RNGs and is suggested its improvement. A separate algorithm is also proposed which returns a full period xorshift generator with desired number of xorshift operations.%We also introduce the notion of tweaked primitive multiple-recursive matrix method with improved linear complexity.

Tables

Table 1. Table 1. States of xorshift RNG

Iteration No.	States of xorshift generator
1	$(d,\stackrel{\text{(n-1) times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}})$
2	$(\mathrm{𝟎},d,\stackrel{\text{(n-2) times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}})$
3	$(\mathrm{𝟎},\mathrm{𝟎},d,\stackrel{\text{(n-3) times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}})$
⋮	⋮
$n$	$(\stackrel{\text{(n-1) times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}},d)$
$n+1$	$(\frac{d}{2},\stackrel{\text{(n-1) times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}})$
$n+2$	$(\mathrm{𝟎},\frac{d}{2},\stackrel{\text{(n-2)times}}{\overbrace{\mathrm{𝟎},\mathrm{𝟎},\cdots ,\mathrm{𝟎}}})$
⋮	⋮

Table 2. Table 2. Average timing for different values of m 𝑚 m

Word size	Time taken (sec)	Time taken (sec)
$m$	to generate ${10}^9$ bits	to generate ${10}^{10}$ bits
8	78.6	841
16	20.02	215
32	5.95	62.74
64	1.94	19.17

Equations

$$R=\left(\begin{array}[]{ccccc}0&0&\cdots&0&0\\ 1&0&\cdots&0&0\\ 0&1&\cdots&0&0\\ \vdots&\vdots&\ddots&\vdots&\vdots\\ 0&0&\cdots&1&0\\ \end{array}\right)_{m\times m}$$

$$s_{i+n}=-(c_0{s}_i+c_1{s}_{i+1}+\cdots +c_{n-1}{s}_{i+n-1})$$

$$T=\left(\begin{array}[]{ccccc}0&1&0&\ldots&0\\ 0&0&1&\ldots&0\\ \vdots&\vdots&\vdots&\ddots&\vdots\\ 0&0&0&\ldots&1\\ c_{0}&c_{1}&c_{2}&\ldots&c_{n-1}\end{array}\right)_{n\times n}$$

$$T=\left(\begin{array}{ccccc}0& I_m& 0& .& 0\\ 0& 0& I_m& .& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& 0& 0& .& I_m\\ (1+L^a)(1+R^b)& 0& 0& .& (1+R^c)\end{array}\right)$$

$$C_i={\left(\begin{array}{ccccc}0& 0& \dots & 0& a_i\\ 0& 0& \dots & 0& a_{n+i}\\ 0& 0& \dots & 0& a_{2n+i}\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& \dots & 0& a_{(m-1)n+i}\end{array}\right)}_{m\times m}$$

$$C_0={\left(\begin{array}{ccccc}0& 0& \dots & 0& a_0\\ 1& 0& \dots & 0& a_n\\ 0& 1& \dots & 0& a_{2n}\\ ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& \dots & 1& a_{(m-1)n}\end{array}\right)}_{m\times m}$$

$$T=\left(\begin{array}{ccccc}0& I_m& 0& .& 0\\ 0& 0& I_m& .& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& 0& 0& .& I_m\\ C_0& C_1& C_2& .& C_{n-1}\end{array}\right)$$

$$T\mathbf{S}$$

$$M(X)={\left(\begin{array}{cccccc}{X}^n& 0& 0& \cdots & 0& f_0\\ -1& X^n& 0& \cdots & 0& f_1\\ 0& -1& X^n& \cdots & 0& f_2\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & X^n& f_{m-2}\\ 0& 0& 0& \cdots & -1& f_{m-1}+f_m{X}^n\end{array}\right)}_{m\times m}$$

$${\left(\begin{array}{cccccc}0& 0& 0& \cdots & 0& g_0\\ -1& 0& 0& \cdots & 0& g_1\\ 0& -1& 0& \cdots & 0& g_2\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 0& g_{m-2}\\ 0& 0& 0& \cdots & -1& g_{m-1}\end{array}\right)}_{m\times m}$$

$$g_0$$

$$g_1$$

$$g_2$$

$$g_{m-2}$$

$$g_{m-1}$$

$$\det \left(M(X))\right)=\det \left(\begin{array}{cccccc}0& 0& 0& \cdots & 0& g_0\\ -1& 0& 0& \cdots & 0& 0\\ 0& -1& 0& \cdots & 0& 0\\ ⋮& ⋮& ⋮& \ddots & ⋮& ⋮\\ 0& 0& 0& \cdots & 0& 0\\ 0& 0& 0& \cdots & -1& 0\end{array}\right)=(-1{)}^{2(m-1)}{g}_0.$$

$$T\mathbf{S}$$

$$A\mathbf{s}=s_{m-1}{\mathbf{v}}_m$$

$$T\mathbf{S}=({\mathbf{s}}_1,{\mathbf{s}}_2,\dots ,{\mathbf{s}}_{\mathbf{n}-1},{\mathbf{s}}_{\mathbf{n}})$$

$${\mathbf{s}}_{\mathbf{n}}=(R{\mathbf{s}}_i+{\alpha }_0\mathbf{v}{}_0+{\alpha }_1{\mathbf{v}}_1+\cdots +{\alpha }_{n-1}{\mathbf{v}}_{n-1})$$

$$(n_1+2)\lceil \frac{l}{m_1}\rceil \le$$

$$(n_2+2)\lceil \frac{l}{m_2}\rceil \le$$

$$N_1$$

Full text

1. Introduction

Random bits are required in many areas including in cryptography, computer simulation, statistical sampling, etc. A True Random Number Generator (TRNG) can be used to generate these random bits. However, the TRNG design uses some uncontrollable physical processes as a source of true randomness and in most practical environments this is an inefficient procedure. So, a Pseudo Random Number Generator (PRNG) can be used in place of a TRNG. PRNG takes a small bit length seed (random) as input and produces a very large binary sequence which appears to be random. The concept of PRNG motivates the design of stream ciphers and in stream cipher design, Linear Feedback Shift Register (LFSR, see Golomb [12], Lidl and Niederreiter [18]) is used as one of the important basic building blocks.

The LFSR is very popular in hardware as it has fast and low cost of implementation in hardware. If it is primitive, then it produces maximum length periodic bitstream for any nonzero initial state. Also, bitstream generated by the LFSR have very good statistical properties. However, it produces only one new bit in each cycle, so such ciphers are often referred as bit-oriented ciphers and could not take the advantage of available word based modern operations. However, the word based LFSR called MRMM [14, 22, 24, 26] takes this advantage. By Zeng at el., it is called as $\sigma$-LFSR  [38]. It is shown in [5, 34] that Marsaglia’s xorshift RNGs are special case of the MRMMs.

In this paper, we have given an algorithm which constructs xorshift RNGs from a binary primitive polynomial. Later, we have found a weakness in these RNGs generated from this algorithm and suggested a solution to overcome this weakness. The paper is organized as follows. In Section 2, we introduce some notations, definitions and results concerning to the primitive LFSRs and xorshift generators. We propose the construction algorithm for xorshift RNGs in Section 3. In Section 4, some results and issues pertaining to the xorshift RNGs produced by construction algorithm are discussed. Finally, conclusion is made in Section 5.

2. Notation and theory

Let ${\mathbb{F}}_{q}$ denote the finite field with $q$ elements, where $q$ is a prime power and ${\mathbb{F}}_{q}$[X] be the ring of polynomials in one variable $X$ with coefficients in ${\mathbb{F}}_{q}$. Denote $M_{m}$(${\mathbb{F}}_{q}$) the set of all $m\times m$ matrices with entries in ${\mathbb{F}}_{q}$ and $GL_{m}$(${\mathbb{F}}_{q}$) be the set of all $m\times m$ invertible matrices. For $C\in M_{m}(\mathbb{F}_{q})$, $C_{ij}$ denotes the entry of the matrix $C$ at $i^{th}$ row and $j^{th}$ column. For any square matrix $C$, det$(C)=|C|$ denotes its determinant whereas $C^{T}$ denotes the transpose of the matrix $C$. $ord(C)$ denotes the period of the matrix $C$. $\lceil n\rceil$ denotes least positive integer greater than or equal to $n$. Let $R\in M_{m}(\mathbb{F}_{2})$ be the right shift operator defined as $Rx=(0,x_{1},x_{2},\ldots,x_{m-1})^{T}$, where $x=(x_{1},x_{2},\ldots,x_{m})^{T}\in\mathbb{F}_{2}^{m}$. Then the matrix form of $R$ is as follows

[TABLE]

Similarly, let $L$ be the left-shift operator defined as the transpose of the matrix $R$, i.e., $Lx=L(x_{1},x_{2},\ldots,x_{m})^{T}=(x_{2},x_{3},\ldots,x_{m},0)^{T}$. For a positive integer $k$, $L^{k}$ means $L$ is applied for $k$ times i.e., $k$ is the amount of shifting in left direction and $R^{k}$ is defined similarly. It is easy to see that both $L^{k}x$ and $R^{k}x=0$ if $k\geq m$. Let $I_{m}\in GL_{m}(\mathbb{F}_{q})$ be the identity matrix.

2.1. LFSR

A sequence $s_{0},s_{1},s_{2},\ldots$ with elements from a finite field ${\mathbb{F}}_{q}$ is called periodic if there exists a nonnegative integer $p$ such that $s_{i+p}=s_{i}$ for all $i\geq 0$. The smallest such integer $p$ is called the period of the sequence. For a periodic sequence, it is always possible to have a relation called linear recurring relation (LRR) [18] among the elements as

[TABLE]

where $c_{i}\in$ ${\mathbb{F}}_{q}$ and the integer $n$ is called the degree of the LRR. It is well known that for a given periodic sequence in ${\mathbb{F}}_{q}$  there is a minimum degree LRR which satisfy the periodic sequence. The associated polynomial $f(x)=x^{n}-c_{n-1}x^{n-1}-\ldots-c_{1}x-c_{0}$ is called the characteristic polynomial of the LRR. The companion matrix $T$ of the polynomial $f$ is as follows

[TABLE]

If the column vector $S_{0}=(s_{0},s_{1},\ldots,s_{n-1})^{T}\in\mathbb{F}_{q}^{n}$ is the initial states of the LFSR, then $S_{1}=T(S_{0})=(s_{1},s_{2},\ldots,s_{n})$ where $s_{n}$ is calculated using the equation (1). The successive states of the LFSR are obtained by repeated application of $T$. If $S_{k}$ be the states of the LFSR after $k^{th}$ iteration, then $S_{k}=T^{k}(S_{0})$. Again, it is proved that the sequence generated by the LRR have period ($q^{n}-1$) if and only if the polynomial associated with the LRR is a primitive polynomial of degree $n$ over the field ${\mathbb{F}}_{q}$ [18, 32] .

The primitive LFSRs have very nice properties. The primitive LFSRs produce bit sequence which not only have a large period, but also have good statistical properties required for cryptographic applications. Again, they have low cost of implementation in hardware [32, 36]. So, the LFSRs are quite useful in generation of pseudorandom bit sequences. However, LFSR prosduce only one new bit in cycle and in many situations such as high speed link encryption, an efficient software encryption technique is required. In such cases, bit-oriented ciphers do not provide adequate efficiency. In case of the LFSR of order $n$, total $n$ shifting along with the feedback computation is needed to produce one bit output. Thus, a single LFSR takes $O(n)$ bit manipulations in order to produce only a single bit. Therefore, in case of software implementation point of view, the LFSR does not take the advantage of the available word based modern processors. However, the generalization of the LFSRs called word based LFSRs (i.e., MMRMs) like xorshift RNGs take this advantage.

2.2. Xorshift generator

Xorshift generator [28] introduced by Marsaglia is a linear operator $T$, which uses only two word based operations called shifting (both right and left) and exclusive-or (XOR). The basic idea of xorshift generators is that the state is modified by applying repeatedly shift and XOR operations. If $\mathbf{S}_{0}=(\mathbf{s_{0}},\mathbf{s_{1}},\ldots,\mathbf{s_{n-1}})^{T}\in\mathbb{F}_{2}^{mn}$ is the initial seed, where each $\mathbf{s_{i}}$ is $m$-bit in size, then {$T\mathbf{S}_{0},T^{2}\mathbf{S}_{0},T^{3}\mathbf{S}_{0},\ldots$} is the sequence of words generated by $T$. Note that, in case of xorshift RNGs, $T\mathbf{S}$ can be computed using a small number of xorshift operations for any $\mathbf{S}\in\mathbb{F}_{2}^{mn}$. The companion matrix of this operator $T$ in the block form is

[TABLE]

where $a,b,c$ are three positive integers and each block is an $m\times m$ matrix. Here $\mathbf{0}$ is the $m\times m$ zero matrix and $T\mathbf{S}_{0}=(\mathbf{s_{1}},\mathbf{s_{2}},\ldots,$ $\mathbf{s_{n-1}},A\mathbf{s_{0}}+B\mathbf{s_{n-1}})$, where $A=(1+L^{a})(1+R^{b})$ and $B=(1+R^{c})$. So its implementation requires only a few number of xorshift operations per pseudo-random number. Again, the xorshift generators have implementation advantages when the size of the each state in bits is a multiple of the computer word size $m$ (typically $m$ = 32 or 64). The xorshift RNGs are extremely fast and there are several values of triplet $(a,b,c)$ for which the companion matrix $T$ has maximal period. Marsaglia [28] lists all those triplets $(a,b,c)$ that yield maximal period xorshift generators with $m=32$ and $m=64$. Later it was verified by Panneton and L’Ecuyer [34] and also shown some deficiencies after analyzing this class of generators. Brent also discussed a potential problem related to correlation of outputs with low Hamming weights and suggested a technique to overcome that problem [5].

From equation-2, it is clear that the dimension of the matrix $T$ is $mn\times mn$ and so the maximal period of $T$ could be $2^{mn}-1$. Let $P(z)=det(T-Iz)$ be the characteristic polynomial of $T$, then $T$ is full periodic (i.e., $ord(T)=2^{mn}-1)$ if and only if $P(z)$ is a primitive polynomial over the binary field ${\mathbb{F}}_{2}$[18, 32]. The list of triplet $(a,b,c)$ were listed out as follows

• •

It first constructs the matrix $T$ using the triplet$(a,b,c)$ as in equation (2).

• •

Checks the primitiveness of the characteristic polynomial $P(z)$ of the matrix $T$.

• •

If $P(z)$ is primitive, then the triplet $(a,b,c)$ is added to the list.

In this process, to get one such triplet it needs several attempts for primitiveness checking of the polynomial $P(z)$. Now, we are proposing an algorithm which does the reverse i.e., it first finds a primitive polynomial and then constructs a xorshift generator $T$ from this primitive polynomial. The construction algorithm is described in the following section.

3. Construction algorithm for xorshift RNG

In this section, we present the algorithm which constructs a xorshift RNG from a given primitive polynomial. Let $f(X)=\displaystyle\sum_{i=0}^{mn}a_{i}X^{i}$ be a polynomial of degree $mn$ over ${\mathbb{F}}_{2}$. Then using the coefficients $a_{i}$’s define $n$ number of $m\times m$ matrices $C_{i}$ for $i=1,2,\ldots,n-1$ as below

[TABLE]

i.e., at least first $(m-1)$ columns are zero columns. Again, define the matrix $C_{0}$ in the following form

[TABLE]

Now, using the matrix coefficients $C_{0},C_{1},\ldots,C_{n-1}$, constructs the matrix $T$ of size $mn\times mn$ as given in the equation-5

[TABLE]

Then, for the column vector $\mathbf{S}=(\mathbf{s_{0}},\mathbf{s_{1}},\ldots,\mathbf{s_{n-1}})^{T}$

[TABLE]

Let $M(X)=I_{m}X^{n}-C_{n-1}X^{n-1}-\cdots-C_{1}X-C_{0}$. Then $M(X)$ is an $m\times m$ matrix polynomial. We call $M(X)$ as the matrix polynomial corresponding to the polynomial $f(X)$. Using the following results, it is possible to calculate the determinant of an $mn\times mn$ matrix from the determinant of an $m\times m$ matrix [1, lemma 2.3].

Lemma 3.1**.**

Let $T$ be the matrix corresponding to the polynomial $f(X)$ of degree $mn$ as defined in (5). Then the characteristic polynomial of $T$ is equal to the determinant of $M(X)$.

Lemma 3.2**.**

Let $M(X)$ be the matrix polynomial corresponding to the polynomial $f(X)$ of degree $mn$ over ${\mathbb{F}}_{q}$. Then the determinant $|M(X)|$ is equal to $f(X)$.

Proof.

The matrix form of $M(X)$ is

[TABLE]

where $f_{i}(X)=\displaystyle\sum^{(i+1)n-1}_{k=in}a_{k}X^{k-in}$ for $i=0,1,\ldots,(m-1)$ and $f_{m}(X)=a_{mn}\neq 0$. Multiply $X^{n}$ with the $n^{\rm th}$ row and add to the $(n-1)^{\rm th}$ row of the above matrix $M(X)$. This will remove $X^{n}$ from the $(n-1)^{\rm th}$ row without any change in the determinant. Now, add $X^{n}$ times the new $(n-1)^{\rm th}$ row to the $(n-2)^{\rm th}$ row. This will remove $X^{n}$ from the $(n-2)^{\rm th}$ row. Continue this procedure till all the ${X^{n}}$ terms on the main diagonal have been removed. Then, the resultant matrix will have the same determinant as $M(X)$ and it will be in the following form

[TABLE]

where

[TABLE]

After suitable operations, it can be shown that

[TABLE]

But $g_{0}=f(X)$ and thus proves the lemma. ∎

From Lemma 3.1 and Lemma 3.2, it is clear that the characteristic polynomial of $T$ is primitive if the polynomial $f(X)$ is primitive. Therefore, if $f(X)$ is primitive, then $T$ is full periodic i.e., $ord(T)=(2^{mn}-1)$ [18, 32]. Our next goal is to show that the matrix operator $T$ belongs to the class of xorshift RNGs. Let $\mathbf{S}=(\mathbf{s_{0}},\mathbf{s_{1}},\ldots,\mathbf{s_{n-1}})^{T}\in\mathbb{F}_{2}^{mn}$, where each $\mathbf{s_{i}}\in\mathbb{F}_{2}^{m}$ and then using equation-5

[TABLE]

Note that all the matrix coefficients $C_{i}$ given in equation (3) and (4) used in equation-8 have a special form. The construction algorithm for xorshift RNGs takes the advantage of these special structures. It is easy to see that the matrix $C_{0}$ can be written as $C_{0}=R+\widehat{C_{0}}$, where $R$ is the right shift operator and $\widehat{C_{0}}$ is an $m\times m$ matrix having first $(m-1)$ zero columns. Note that the last column of both $\widehat{C_{0}}$ and $C_{0}$ are same and the structure of $\widehat{C_{0}}$ is exactly same as $C_{j}$, for $j\geq 1$. Because of the following lemma, we will show that $T\mathbf{S}$ can be computed using only xorshift operations.

Lemma 3.3**.**

[1]** For any matrix $A\in M_{m}(\mathbb{F}_{2})$ having all the columns zero except the $m^{\rm th}$ column and for any vector ${\mathbf{s}}=[s_{0},s_{1},\ldots,s_{m-1}]^{T}\in\mathbb{F}_{2}^{m}$, we have

[TABLE]

where ${\mathbf{v}}_{m}$ represents the $m^{\rm th}$ column of the matrix $A$.

By invoking Lemma 3.3, $T\mathbf{S}$ can be rewritten as follows:

[TABLE]

where,

[TABLE]

and $\alpha_{i}$ is the least significant bit (LSB) of ${\mathbf{s}}_{i}$ and ${\mathbf{v}}_{i}$ is the $m^{\rm th}$ column of the matrix $C_{i}$ ($0\leq i\leq n-1)$, that is ${\mathbf{v}}_{i}=[a_{i},a_{n+i},\ldots,a_{(m-1)n+i}]^{T}$. It is clear that the equation (9) can be computed by using only one right shift operation and at most $n$ XOR operations and thus, it falls into the class of Marsaglia’s xorshift RNGs. We call equation (9) as feedback computation function.

Now we are in a position to propose the construction algorithm for xorshift RNGs. The sequential steps of the construction algorithm are described in Algorithm 1.

The complexity of the Algorithm 1 is O(1) as it generates a primitive xorshift generator $T$ from a given primitive polynomial just by expressing the coefficients in matrix form.

Lemma 3.4**.**

The primitive xorshift RNGs of order $n$ over ${\mathbb{F}}_{2^{m}}$ generated by Algorithm 1 will have at least two and at most $(n+1)$ xorshift operations in the feedback function computation.

Proof.

Algorithm 1 generates primitive xorshift RNGs from the primitive polynomial and again, the constant term of the primitive polynomial must be nonzero i.e., $a_{0}\neq 0$. This implies ${\mathbf{v}}_{0}\neq 0$ as ${\mathbf{v}}_{0}=[a_{0},a_{n},\ldots,a_{(m-1)n}]^{T}$. Again, in the recurrence relation (9), the right shift $R$ will be present irrespective of any polynomial. So there will be at least two xorshift operations in the feedback computation. Also, in equation (9), there are almost $(n+1)$ nonzero terms. This completes the proof. ∎

4. A note on construction algorithm for xorshift generators

The xorshift generators generated from the primitive polynomials and so are full periodic. For every primitive polynomial of degree $mn$, it constructs distinct xorshift generator. Therefore, total number of full periodic xorshift generators of order $n$ over the field ${\mathbb{F}}_{2^{m}}$ produced by this algorithm is $\frac{\phi(2^{mn}-1)}{mn}$.

4.1. Weakness in Initialization of xorshift generator States

The primitive xorshift RNGs generated by the construction algorithm have efficient software implementation property, however from cryptographic point of view they have a weakness similar to the Lagged Fibonacci Generator (LFG)[16, 3]. In LFG, if all states are initialized with even numbers, then the feedback value will be always even in every iteration. To counter this weakness, at least one state of the LFG must be initialized with an odd value. Similar kind of weakness is also present in the xorshift RNGs constructed by Algorithm 1. If first $(n-1)$ states (i.e., ${\mathbf{s}}_{0},{\mathbf{s}}_{1},\ldots,{\mathbf{s}}_{n-2}$) of the xorshift RNG generated by the construction algorithm are even, then there will be only one active term in the feedback value computation i.e., $R{\mathbf{s}}_{i}$. This happens because the $\alpha_{i}$ defined in equation (9) is the least significant bit (LSB) of the state ${\mathbf{s}}_{i}$ and so equal to zero for even value of ${\mathbf{s}}_{i}$. If all states are multiple of $2^{l}$ i.e., ${\mathbf{s}}_{i}=2^{l}k_{i}$, then there will be only one active component in the feedback function computation till $nl$ many iterations and for $0<j<nl$, ${\mathbf{s}}_{n+j}=R^{j_{1}}{\mathbf{s}}_{j_{2}}$, where $j_{1}=\lceil\frac{j}{n}\rceil$ and $j_{2}=(j-1)$ mod $n$.

In particular, if the states ${\mathbf{s}}_{i}$ for $0\leq i<(n-1)$ are zero vectors and ${\mathbf{s}}_{n-1}=d$, where $d$ is a multiple of $2^{l}$, for some integer $l>0$, then the table-1 gives the states of xorshift generator after the subsequent iterations.

If the content of stage 0 is the output word in each iteration, then the first $nl$ words of the output sequence produces by the xorshift generator is as follows

$\overbrace{\mathbf{0},\mathbf{0},\cdots,\mathbf{0}}^{\textnormal{(n-1) times}},\dfrac{d}{2},\overbrace{\mathbf{0},\mathbf{0},\cdots,\mathbf{0}}^{\textnormal{(n-1) times}},\dfrac{d}{2^{2}},\cdots,\overbrace{\mathbf{0},\mathbf{0},\cdots,\mathbf{0}}^{\textnormal{(n-1) times}},\dfrac{d}{2^{l}},\cdots$

Here each word is $m-$bit wide. There are $(n-1)$ zero vectors in each $n$ consecutive output words till the $nl^{th}$ iteration. Note that, with initial states $(d,\mathbf{0},\mathbf{0},\cdots,\mathbf{0})$ with $d=2^{l}k$, the first $ln$ outputs are same irrespective of any primitive xorshift RNGs of order $n$ constructed by Algorithm 1. So, the initial value of the states of the xorshift generator produced by the construction algorithm are significant for the quality of pseudorandom vectors generation. To avoid this weakness, the initial states of the xorshift RNG need be initialized with odd numbers. In such case, all $\alpha_{i}$ will be equal to $1$ at the first iteration and there will be maximum number of active terms for the feedback function computation.

4.2. Different xorshift generators from same binary primitive polynomial

One of the important thing of the construction algorithm is that it produces different primitive xorshift generators of different order from a given binary primitive polynomial of degree $mn$. Since in most of the operating system, the word size is of the form $2^{k}$, we have considered $mn=2^{k}$ for some positive integer $k$. Again for $mn=2^{k}$, there will be $(k-1)$ distinct possible choices for $m$ i.e., $1,2^{1},\ldots,2^{k-1}$. For each value of $m$, the construction algorithm returns $n$ vectors $\{v_{0},v_{1},\ldots,v_{n-1}\}$, where each $v_{i}$ is of $m$-bit length. For better understanding, see the following example.

Example 4.1**.**

Let us consider the binary primitive polynomial $f(x)=x^{32}+x^{31}+x^{27}+x^{26}+x^{25}+x^{20}+x^{19}+x^{15}+x^{14}+x^{11}+x^{9}+x^{7}+x^{6}+x^{5}+x^{4}+x^{2}+1$. Here degree of $f(x)$ is 32 and so $mn=32=2^{5}$. Then the set of possible choices for $m$ is $\{1,2^{1},2^{2},2^{3},2^{4}\}$. But, we are only considering $m=2^{3}$ and $2^{4}$. The respective xorshift RNGs constructed using Algorithm 1 are given below.

1. (1)

For $m=2^{3}$ and $n=2^{2}$:

$v_{0}=0$x$f7$, $v_{1}=0$x$54$, $v_{2}=0$x$73$, $v_{3}=0$x$bf$. 2. (2)

For $m=2^{4}$ and $n=2$:

$v_{0}=0$x$bf2f$, $v_{1}=0$x$6775$.

From equation (9), it is clear that for a xorshift generator of order $n$ over the field ${\mathbb{F}}_{2^{m}}$ requires following operations in each iteration

• •

For computation of the feedback value $fd$ as given in (9), it requires one right shift operation and at most $n$ XOR operations.

• •

$n$ state shifting operations i.e., $\mathbf{s_{i}}=\mathbf{s_{i+1}}$ for $i=0,1,\ldots,n-2$ and $\mathbf{s_{n-1}}=fd$.

Then, using Lemma 3.4, it is clear that at least ($n+2)$ and at most $(2n+1)$ xorshift operations are needed to produce an $m-$bit word in each cycle. Thus, to produce a bitstream of length $l$, it will take $\lceil\frac{l}{m}\rceil$ many iterations. If $N$ is the total number of word operations (XOR, right shift and shifting), then $(n+2)\lceil\frac{l}{m}\rceil\leq N\leq(2n+1)\lceil\frac{l}{m}\rceil$. Suppose for a binary primitive polynomial of degree $mn$, two separate primitive xorshift RNGs (RNG1 and RNG2) are generated with word size $m_{1}$ and $m_{2}$ respectively, where $m_{2}=2m_{1}$. Let, the respective order of RNG1 and RNG2 be $n_{1}$ and $n_{2}$, then $n_{1}=\frac{mn}{m_{1}}$ and $n_{2}=\frac{mn}{m_{2}}=\frac{mn}{2m_{1}}$. If $N_{1}$ and $N_{2}$ be the total number of operations required to generate bitstream of length $l$, then we have

[TABLE]

Therefore,

[TABLE]

Again,

[TABLE]

Using equations (10) and (11), we have $2<\frac{N_{1}}{N_{2}}<8$. Therefore, for larger value of $m$, the xorshift generator will take lesser number of word operations to produce the bitstream of desired length $l$ and so will take lesser time which is reflected in our experimental results given in the table 2.

For our experiment, we have taken $mn=512$ and the bitstream length $l$ as $10^{9}$ and $10^{10}$. Then for $m=8,16,32,64$, measured the average time taken to generate bitstream of length $l$. It is observed that if the word size $m$ is increased by 2, then the time taken reduced by $c$ to generate a fixed length bitstream, where $2<c<8$. The construction algorithm for primitive xorshift RNGs is implemented in C and the used Test machine is Intel Xeon(R) CPU E5645 @ 2.40GHz x 12 with 8 GiB memory and 64-bit Linux operating system. The table 2 summarize the results, which tells that it is better to select the primitive xorshift RNG having larger word size $m$ (i.e., 32 or 64) so as to take the advantage of modern word based operations.

4.3. Primitive xorshift generator with Desired Number of Tap Points

The effect of number of tap points in the LFSR (i.e., the number of nonzero coefficients) is important for cryptographic usage while choosing a primitive polynomial. Because an LFSR with less number of tap positions is susceptible to fast correlation attack [9, 10]. The distribution of polynomials over ${\mathbb{F}}_{2}$ with respect to their weights are well studied in [30]. It is desirable to select the primitive polynomial whose weight is close to $\frac{n}{2}$ i.e., the polynomial is neither too sparse nor too dense [7, 34]. However, in certain areas like light weight cryptography, it is preferable to have less number of nonzero tap positions. So, it is required to have an algorithm which could generate primitive xorshift RNGs of order $n$ over ${\mathbb{F}}_{2^{m}}$ with desired number of tap points $k$, where $1<k<n+2$. In case of Marsaglia’s xorshift RNGs, there are total six operations (i.e., three XOR and three shifting) are used in the feedback function computation. Algorithm 2 produces such primitive RNGs with desired number of xorshift operations $k$.

From lemma-3.4, it is shown that in case of primitive xorshift RNGs there will be at least two operations for its feedback computation (i.e., $R$ and $\alpha_{0}{\mathbf{v}}_{0}$). Therefore, for getting a primitive xorshift generator with $k$ xorshift operations for its feedback computation, Algorithm 2 assigns random binary value to the coefficients needed for the matrix coefficient $C_{0}$ as given in equation (4) with $a_{0}=1$. Next it selects $(k-2)$ distinct random integer $i$ such that $0<i<n$ and then constructs the random binary matrix coefficients $C_{i}$ as described in equation (3). Finally, assign $a_{mn}=1$ so that the polynomial $f(X)=\displaystyle\sum_{i=0}^{mn}a_{i}X^{i}$ will be a polynomial of degree $mn$. If $f(x)$ is primitive, then Algorithm 1 returns the desired primitive xorshift generator.

5. Conclusion

In this paper, we have proposed two algorithms related to Marsaglia’s xorshift RNGs. Algorithm 1 constructs primitive xorshift generator from a given primitive polynomial. We studied those xorshift generators and found a common weakness in all those generators. It is shown that the states of those xorshift generators need to be initialized carefully and is suggested that all the states to be initialized with odd numbers. We have shown that several primitive xorshift generators of different order can be constructed from a given primitive polynomial of degree $mn$ using the construction algorithm. We also shown that for the larger value of word size $m$, the xorshift generator takes less time to produce a bitstream of the desired length $l$. So, in case of software implementations, it is suggested to select the primitive xorshift generators with a larger word size $m$ (i.e., 32 or 64) to take the advantage of modern word based operations. Finally, We have provided another algorithm that produces efficient primitive xorshift generator with desired number of xorshift operations needed for computation of its feedback function .