Application of Decimated Mathematical Equations and Polynomial Root-Finding Method in Protection of Text Messages

Abstract

Cryptography is the process of transforming data so that only the recipient of the message can read it. It uses an algorithm and a key to convert an input into an encrypted output. In this study, we introduce a novel method for protecting readable messages through the utilization of a polynomial root-finding technique in conjunction with the decimated output of Zaslavsky equations. The innovative approach we have developed is a block encryption algorithm that offers both protection for sensitive information as well as adaptability to various block sizes, including dynamically changing block sizes. Precise security analysis is provided for the proposed algorithm using key space analysis and strong statistical tests. The presented results show that the novel block encryption protection provides a high level of security.

1. Introduction

The modern communication revolution necessitates faster and more secure methods of ensuring plain message security. It is crucial to have better options in order to be more secure in today’s world. Cryptography is the practice of transforming data into an unrecognizable form to protect them from being illegally obtained, altered, modified, or accessed while being transmitted over a network. In recent years, many encryption techniques have been introduced to securely store and transfer data in text format. Message encryption is a deterministic scheme operating on fixed-length encryption groups of bits. These include extensively used classical encryption schemes (RSA, Blowfish, AES, etc.) and novel encryption schemes (based on dynamical systems [1,2,3] and quantum walks [4,5,6]).

Due to the increasing resistance to statistical attacks, the use of strong mathematical tools in encryption schemes is becoming more and more popular. A symmetric text encryption technique based on reversible Karhunen–Loeve expansion is proposed in [7]. The proposed algorithm is sufficiently secure based on the security measures. In Ref. [8], a data encryption scheme based on deep learning is presented. It performs well in secrecy capacity. In [9], a data encryption technique based on a numerical method and rotation–translation formula is proposed. Two different ways of constructing nonlinear functions are presented. Text encryption based on logistic, pinchers, and sine-circle equations is described in [10]. Pseudorandom bit extraction from Lorenz and Rössler attractors is presented in [11]. Different numerical methods for solving nonlinear dynamic systems are available. In Ref. [12], a variant of the RSA scheme is used to secure simple input messages. Core-adaptive Fourier decomposition for high encryption performance and security is described in [13].

Decimation is the process of reducing the random or pseudorandom output stream with a filtering function. Irregularly based encryption schemes can be found in [14,15].

1.1. Motivation and Related Works

Our study was inspired by the rising demand for more complex and reliable encryption as a result of the advancement in computer and network technology. The main motivation of this paper is to design and propose an encryption method suitable for readable massages protection. In [9], we introduced an enhanced encryption algorithm. Our research focuses on advancing encryption techniques, emphasizing both efficiency and security in data protection. We developed an algorithm using numerical methods and the rotation–translation equation to create a symmetric-key-based encryption–decryption system. Our goal was to improve the existing encryption methods by incorporating a faster convergent iterative approach, ensuring secure convergence of the numerical scheme, and enhancing security through the use of a rotation–translation formula.

As far as the authors are aware, the studies that examine encryption algorithms with iterative techniques include [9,11,16,17,18,19]. Publications [9,16,17,18] discuss encryption techniques that use numerical methods to solve nonlinear algebraic equations. Meanwhile, in [11], an encryption technique is considered where numerical methods are used to solve differential equations. In [19], the use of the Zaslavsky function to construct a hash function is demonstrated. For some more recent results based on the chaotic-map Zaslavsky equation, we recommend [20,21,22] and the citations therein.

The present work is a kind of continuation and expansion of the ideas and approach from publication [9]. Our goal is to present a new block encryption technique based on iterative methods for simultaneous approximation of polynomial zeros in conjunction with the decimated output of Zaslavsky equations.

1.2. Contributions

This research paper introduces a novel approach to text encryption, leveraging the fusion of decimated mathematical equations and the polynomial root-finding method. The proposed algorithm offers a robust and secure method for achieving block encryption, enhancing the confidentiality and integrity of textual information.

The main contributions of our research can be summarized as follows:

• We present a decimation-based algorithm for pseudorandom byte output using two Zaslavsky equations, which possesses respectable statistical features.
• We propose secure text encryption based on a mix of the polynomial root-finding method and the decimated output of the novel pseudorandom generator.
• We examine the proposed encryption, and the data show that it has good key space and excellent security properties that can withstand most common theoretical and statistical vulnerabilities.

1.3. Article Structure

The rest of the paper is organized as follows. In Section 2, we propose basics on polynomials, factoring polynomials, and root-finding methods. In Section 3, we propose a novel decimation-based pseudorandom byte generation and text encryption technique. In Section 4, some security cryptanalysis is provided. Finally, Section 5 concludes the paper.

The MATLAB source code and output results are available from [23].

2. Polynomials, Factoring Polynomials, and Root-Finding Methods

This section provides several fundamental facts about polynomials, which will be used in the following sections. Let $n\in \mathbf{Z}\cup \left\{0\right\}$ be a nonnegative integer, and let $a_0,a_1,\dots ,a_n\in \mathbf{C}$ be complex numbers. Then, we call the expression

$$p\left(x\right)=a_n{x}^n+\dots +a_{1}x+a_0$$

(1)

as a polynomial in the variable x with coefficients $a_0,a_1,\dots ,a_n$. The highest power, n, where $a_n\ne 0$, occurring is called the degree of the polynomial. The highest degree term is called the leading term and its coefficient $a_n$ is called the leading coefficient. Moreover, if the leading coefficient is $a_n=1$, we call $p\left(x\right)$ a monic polynomial. Finally, by a root (or zero) of a polynomial $p\left(x\right)$, we mean a complex number $\alpha$ such that $p\left(\alpha \right)=0$.

2.1. Fundamental Theorem of Algebra

The Fundamental Theorem of Algebra has several equivalent formulations and many different proofs. One of the first proofs was provided by the famous mathematician Carl Gauss in his 1799 doctoral dissertation.

Theorem 1

(Fundamental Theorem of Algebra). Given any positive integer $n=1$ and any choice of complex numbers $a_0,a_1,...,a_n$, such that $a_n\ne 0$, the polynomial equation

$$a_n{x}^n+\dots +a_{1}x+a_0=0$$

(2)

has at least one solution $x\in C$.

There are several equivalent formulations of Theorem 1. The theorem is also stated as follows.

Theorem 2.

Let $p\left(x\right)$ be a polynomial with complex coefficients of degree n. Then, $p\left(x\right)$ has n roots.

Theorem 3

(Complex Factorization Theorem). Suppose p is a polynomial function with complex number coefficients. If the degree of p is $n\ge 1$, then p has exactly n complex roots, counting their multiplicity. If ${\alpha }_1,{\alpha }_2,\dots ,{\alpha }_k$ are the distinct roots of p, with multiplicities $m_1,m_2,\dots ,m_k$, respectively, then

$$p\left(x\right)=a{(x-{\alpha }_1)}^{m_1}{(x-{\alpha }_2)}^{m_2}\dots {(x-{\alpha }_k)}^{m_k},$$

(3)

where a is the leading coefficient of $p\left(x\right)$.

It follows from Theorem 3 that a polynomial is completely defined by its zeros, their multiplicities, and its leading coefficient.

2.2. Polynomial Root-Finding

Generally, polynomials’ zeros cannot be computed exactly nor expressed in closed form. Note that there exist closed formulas for the roots of polynomials, only for polynomials up to degree four. This fact was proved by Abel in 1824, and independently by Galois. As a result, most computational methods for solving the root-finding problem are iterative. Essentially, iterative methods work as follows: they start with an initial approximation $x_0$ and then construct a sequence of iterations $x_k$ using an iteration formula in the hope that this sequence converges to a root of $p\left(x\right)$. There are two main types of iteration methods for polynomial root-finding: those that approximate one root at a time and those that approximate all roots at once. A classic representative of methods for simultaneous approximation of all zeros of $p\left(x\right)$ is the famous Weierstrass method, which is defined by the sequence

$${\mathbf{x}}_{k+1}={\mathbf{x}}_k-W\left({\mathbf{x}}_k\right)\mathrm{for}k=0,1,2,\dots ,$$

(4)

where $W:D\subset {\mathbf{C}}^n\to {\mathbf{C}}^n$ is a vector-valued function with components

$$W_i\left(\mathbf{x}\right)=\frac{p\left(x_i\right)}{{\prod }_{j\ne i}^n(x_i-x_j)},\mathrm{for}i=1,\dots ,n,$$

(5)

and D is the set of all vectors with distinct components in ${\mathbf{C}}^n$. Weierstrass sequence (4) is well-defined under appropriate initial conditions and converges to the polynomial p’s zero vector. Provided that all p zeros are simple, the iteration has quadratic convergence.

Matrix methods can also be used to approximate polynomial roots. Over the past few decades, they have gained popularity for simultaneously finding polynomial roots. With this approach, the zeros of the input polynomial p are approximated as the eigenvalues of the companion matrix (or generalized companion matrix). It is known that a matrix $A\in {\mathbf{C}}^{n\times n}$ is a companion matrix associated with the polynomial $p\left(x\right)$ if

$$det(A-\mathbf{x}I)=p\left(x\right)$$

(6)

for $\mathbf{x}\in {\mathbf{C}}^n$. In mathematical terms, p denotes the characteristic polynomial of A. Thus, eigenvalues of A coincide with the zeros ${\alpha }_1,\dots ,{\alpha }_n$ of p. Therefore, the polynomial root-finding problem can be reduced to the eigenvalue problem: find a scalar $\lambda \in \mathbf{C}$ and a nonzero vector $\mathbf{x}\in {\mathbf{C}}^n$ such that

$$A\mathbf{x}=\lambda \mathbf{x}.$$

(7)

The most common example of companion matrices is the well-known Frobenius companion matrix of order n

$$A=\left(\begin{array}{ccccc}0& 1& 0& \dots & 0\\ 0& 0& 1& \dots & 0\\ ⋮& ⋮& ⋮& \ddots & ⋮\\ 0& 0& 0& \dots & 1\\ -a_0& -a_1& -a_2& \dots & -a_{n-1}\end{array}\right)$$

(8)

associated with the polynomial p.

This implies the use of different techniques to find matrix eigenvalues. The eigenvalues of the companion matrix may be found by using standard versions of the balancing QR algorithm. These versions may be found in LAPACK or its precursor EISPACK. This is how the MATLAB $\mathrm{roots}$ function performs its computation.

2.3. MATLAB Functions for Root-Finding

MATLAB’s built-in functions $\mathrm{poly}, \mathrm{polyval}$, and $\mathrm{roots}$ can be used in the context of zero-finding of a polynomial. Function $\mathrm{poly}$ converts roots to a polynomial equation. The following syntax $\mathrm{poly}\left(v\right)$, when v is a vector, provides a vector whose elements are the coefficients of the polynomial whose roots are the elements of v.

Function $\mathrm{roots}$ finds the polynomial roots. The following syntax $\mathrm{roots}\left(c\right)$ computes the roots of the polynomial whose coefficients are elements of the vector c.

Function $\mathrm{polyval}$ is for polynomial evaluation. The following syntax $\mathrm{polyval}(p,x)$ evaluates the polynomial p at each point in x. The argument p is a vector of length $n+1$ whose elements are the coefficients (in descending powers) of an n-th degree polynomial.

MATLAB’s built-in functions $\mathrm{poly},\mathrm{polyval}$, and roots are employed for the purpose of locating the roots of a polynomial. The $\mathrm{poly}$ function transforms roots into a polynomial equation. When given a vector v, the syntax $\mathrm{poly}\left(v\right)$ generates a vector containing coefficients corresponding to the polynomial with roots specified by the elements of v. The $\mathrm{roots}$ function determines the roots of a polynomial. Using the syntax $\mathrm{roots}\left(c\right)$, where c is a vector, computes the roots of the polynomial defined by the coefficients in vector c. The $\mathrm{polyval}$ function is utilized for evaluating polynomials. Using the syntax $\mathrm{polyval}(p,x)$, it calculates the value of the polynomial p at each specified point in x. Here, the argument p is a vector of length $n+1$, containing coefficients (in descending powers) of an n-th degree polynomial.

3. Secure Text Encryption Using Polynomial Root-Finding Method and Decimated Output of Zaslavsky Equations

3.1. Proposed Decimation-Based Pseudorandom Byte Generation

In this section, we will describe the Zaslavsky-equation-based [24] pseudorandom byte output generation.

The following function provides a definition of the Zaslavsky formula:

$$\begin{array}{ccc}\hfill y_{n+1}& =& [y_n+\nu (1+\mu z_n)+ϵ\nu \mu cos\left(2\pi y_n\right)](\mathrm{mod}1),\hfill \end{array}$$

(9)

$$\begin{array}{ccc}\hfill z_{n+1}& =& e^{-r}(z_n+ϵcos\left(2\pi y_n\right)),\hfill \end{array}$$

(10)

where

$$\mu =\frac{1-e^{-r}}{r}.$$

(11)

It depends on three constants $\nu$, $ϵ$, and r, where $r=3.0$, $\nu =400/3$, and $ϵ=0.3$ as in [24].

George M. Zaslavsky introduced the novel strange attractor, a discrete-time nonlinear dynamical system, in 1978. The Zaslavsky equation demonstrates deterministic dynamic behavior, a crucial component of modern security algorithms [25,26,27,28,29,30]. The diagram of the Zaslavsky equation has been provided in Figure 1. This diagram shows the random behavior of the Zaslavsky map. One can choose starting values in the interval $[-0.001,0.001]$.

The proposed scheme is based on the following two Zaslavsky equations:

$$\begin{array}{cc}\hfill y_{1,n+1}& =mod(y_{1,n}+\nu (1+\mu z_{1,n})+ϵ\nu \mu cos\left(2\pi y_{1,n}\right),1)\hfill \\ \hfill z_{1,n+1}& =e^{-r}(z_{1,n}+ϵcos\left(2\pi y_{1,n}\right)),\hfill \\ \hfill y_{2,n+1}& =mod(y_{2,n}+\nu (1+\mu z_{2,n})+ϵ\nu \mu cos\left(2\pi y_{2,n}\right),1)\hfill \\ \hfill z_{2,n+1}& =e^{-r}(z_{2,n}+ϵcos\left(2\pi y_{2,n}\right)),\hfill \end{array}$$

(12)

where $\mu$ is from Equation (11) and $y_{1,0}$, $z_{1,0}$, $y_{2,0}$, $\mathrm{and} z_{2,0}$, are floating point numbers.

The complete decimation process consists of the following steps:

• The starting values $y_{1,0}$, $z_{1,0}$, $y_{2,0}$, and $z_{2,0}$ of Equation (12) and an output stream length Z are determined.
• The Zaslavsky equations are iterated initially for M times.
• The iteration of the Equation (12) continues, and, as a result, four decimal fractions $y_{1,m}$, $z_{1,m}$, $y_{2,m}$, and $z_{2,m}$, are generated and two of them post-processed as follows:

  $$\begin{array}{cc}\hfill s_i& =mod(abs\left(int(y_{1,m}\times {10}^{14})\right),2)\hfill \\ \hfill t_j& =mod(abs\left(int(z_{2,m}\times {10}^{14})\right),2),\hfill \end{array}$$

  (13)

  where $int\left(x\right)$ returns the integer part of x, truncating the value at the decimal point, $abs\left(x\right)$ returns the absolute value of x, and $mod(x,y)$ returns the reminder after division. Two bits $s_i$ and $t_j$, are obtained.
• If the bit $(s_i\oplus t_j)!=1$, return to Step 3.
• Post-process the other two values as

  $$\begin{array}{cc}\hfill s_j& =mod(abs\left(int(z_{1,m}\times {10}^{14})\right),256)\hfill \\ \hfill t_i& =mod(abs\left(int(y_{2,m}\times {10}^{14})\right),256),\hfill \end{array}$$

  (14)

  and the byte $(s_j\oplus t_i)$ produces part of the output sequence.
• Return to Step 3 until the byte stream length Z is reached.

The novel decimation-based generator is implemented in MATLAB (R2023b, MathWorks, Natick, MA, USA).

3.2. Proposed Text Encryption Technique

In this section, we describe the encryption and decryption processes of our approach. The complete encryption process consists of the following steps (Algorithm 1):

Algorithm 1: Encryption
Input: Original text $inpT$, Block length $Len$ and K PR bytes.
Output: Encrypted text $encT$
1: Procedure ENCR($inpT$, $Len$, K)
2:  n = length($inpT$);	(Extract the string length)
3:  $numBlocks$ = ceil($n/Len$);	(Compute the number of blocks)
4:  For $k=1:numBlocks$	(Count the blocks)
5:  $currentBlock=inpT\left(k\right);$	(Extract the current block)
6:  K = GenPRG($Len$)	(Random generated array)
7:  $ascii\_codes\_xor$ = double($currentBlock$) xor K;	(Vector of ASCII codes after bit-wise XOR)
8:  P = roots($[1ascii\_codes\_xor]$);	(Solving polynomial)
9:  $encT\left(k\right)=P;$	(Encrypted block)
10:  endFor
11: End Procedure

Decryption is the inverse process of encryption. With ciphertext, block length, and decryption keys, one can obtain the original text following decryption operations. The algorithmic steps of the decryption process are summarized as follows (Algorithm 2).

Algorithm 2: Decryption
Input: Encrypted text $encT$, Block length $Len$ and K PR bytes.
Output: Decrypted text $ReconT$
1: Procedure DECR($encT$, $Len$, K)
2:  n = length($encT$);	(Extract the string length)
3:  $numBlocks$ = ceil($n/Len$);	(Compute the number of blocks)
4:  For $k=1:numBlocks$	(Count the blocks)
5:  $currentBlock=encT\left(k\right);$	(Extract the current block)
6:  K = GenPRG($Len$)	(Random generated array)
7:  p = poly($currentBlock$);	(Construct the monic polynomial)
8:  $ascii\_codes=p(2:end)xorK;$	(Vector of ASCII codes after reverse XOR)
9:  $ReconT\left(k\right)$= native2unicode($ascii\_codes$);	(Decrypted block)
10:  endFor
11: End Procedure

In both algorithms described above, a syntax of the type $currentBlock=encT\left(k\right)$ is used, which means extracting the k-th block of $encT$ with specified block length. At step 6 in both algorithms, an additional function $GenPRG$, not described as pseudocode, is used, which generates an array of random numbers of length $Len$ using the above-described Zaslavsky-based pseudorandom generation scheme. We have used the following Zaslavsky generator parameters: $ϵ=0.3,\nu =0.2$, and $r=5$.

The encryption and decryption schemes are shown in Figure 2 and Figure 3.

3.3. An Example of Encryption

We will use the example below to illustrate the suggested algorithm. The input text is $inpT$ = “Shumen University” and the encrypted symbols, using two types of block encryption, with block lengths $Len=4$ and $Len=5$ are shown in

Table 1. Example of encryption/decryption process.

Letter	ASCII	PR	Polynomial	Encrypted Letter	Encrypted Letter
(Char)	Code	Number	Coefficient	(Block Length = 5)	Block Length = 4
S	83	18	65	−62.8745	−0.6287
h	104	239	135	0.3295 + 1.0652i	−0.0200
u	117	45	88	0.3295 − 1.0652i	−0.0006 − 0.0105i
m	109	230	139	−1.3922 + 0.1368i	−0.0006 + 0.0105i
e	101	252	153	−1.3922 − 0.1368i	−1.5241
n	110	52	90	−89.8704	−0.0133
	32	46	14	0.4709 + 1.6081i	0.0037 − 0.0096i
U	85	131	214	0.4709 − 1.6081i	0.0037 + 0.0096i
n	110	143	225	−0.5357 + 0.5174i	−2.2438
i	105	229	140	−0.5357 − 0.5174i	−0.0001 − 0.0105i
v	118	136	254	−253.4214	−0.0001 + 0.0105i
e	101	246	147	0.2639 + 0.9013i	−0.0059
r	114	16	98	0.2639 − 0.9013i	−0.9553
s	115	159	236	−1.0233	−0.0262
i	105	122	19	−0.0830	0.0008 − 0.0076i
t	116	229	145	−143.3466	0.0008 + 0.0076i
y	121	148	237	−1.6533	−2.3700

. Table 1 shows only the result of the encryption process (Procedure $ENCR$). The result of the decryption (Procedure $DECR$) is actually the ASCII codes shown in Column 2 of Table 1.

The last two columns of Table 1 contain the output array of complex numbers, which is the encrypted text the receiver obtains.

4. Security Analysis

The key space is a group of numbers that can be used in the initial of the pseudorandom generation. The proposed technique has five initial values $y_{1,0}$, $z_{1,0}$, $y_{2,0}$, $z_{2,0}$, M, and Block length. As mentioned in the IEEE Standard for Floating-point Arithmetic [31], the computation accuracy of the 64-bit double-precision number is about ${10}^{14}$. Consequently, the key space exceeds $2^{256}$ bits. This is substantial enough to thwart brute-force attempts [32,33], and it is larger than the key size of the pseudorandom output algorithms proposed in [9,11,19,34,35,36,37].

Using NIST [38] (National Institute of Standards and Technology) and Ent [39] applications, we attempted to determine the algorithm’s unpredictability.

Array E outputs numbers ($e_i$) as bytes according to the formula $s_i=mod(abs\left(int(e_i\times {10}^{14})\right)$, 256). Generating pseudorandom bytes using decimation, 2000 arrays of 125,000 bytes are produced.

The NIST application (version sts-2.1.2) includes 15 tests for randomness. The software calculates how many streams pass the particular test. Based on the confidence interval, an acceptable proportion range can be determined as

$$\widehat{p}\pm 3\sqrt{\frac{\widehat{p}(1-\widehat{p})}{m}},$$

where $\widehat{p}=1-\alpha$ and m is the number of binary streams. There should be at least 1000 sequences of 1,000,000 bits. The value of m in our file is 3000. In this case, the confidence level is

$$0.99\pm 3\sqrt{\frac{0.99\left(0.01\right)}{2000}}=0.99\pm 0.0066746.$$

The proportion should lie above 0.9833254 with exception of random excursion and random excursion variant tests. Only when a sequence has more than 500 cycles do these two tests become relevant.

Ten subintervals make up the interval between 0 and 1. Each subinterval’s corresponding p-values are counted. Applying a ${\chi }^2$ test and figuring out a p-value for the goodness-of-fit check on the p-values acquired for any test, p-value of the p-values, can also be used to specify uniformity:

$${\chi }^2=\sum _{i=1}^{10}\frac{{(F_i-s/10)}^2}{s/10},$$

where s is the sample size and $F_i$ is the number of p-values in the subinterval i. A p-value is calculated as p-$valu{e}_T=IGAMC(9/2,{\chi }^2/2)$, where $IGAMC$ is the complementary incomplete gamma function. If p-$valu{e}_T\ge 0.0001$, it is subsequently possible to regard the sequences as uniformly distributed.

We will present the particular tests briefly [38]: the ratio of ones to zeros throughout the whole sequence is the frequency test’s main focus. The goal of this test is to assess whether a sequence has about the same amount of ones and zeros as would be predicted for a really random sequence. The percentage of ones in M-bit blocks is the block frequency test’s main emphasis. The goal of this test is to evaluate if an M-bit block has a frequency of ones that is around M/2, as would be predicted by the randomness assumption. The maximum excursion (from zero) of the random walk, which is determined by the cumulative total of the adjusted (−1, +1) numbers in the stream, is the main focus of the cumulative sums. Finding out if the cumulative sum of the partial streams that occur in the tested stream deviates too much or too little from the cumulative sum’s expected behavior for random streams is the aim of the test. The primary issue with the sequence is the overall number of runs, where a run is an unbroken string of identical bits. A run of length k is limited before and after by a bit with the opposite value, and it is made up of precisely k identical bits. The runs test is used to check if there are as many runs of ones and zeros as one would anticipate from a random sequence. The longest run of ones within M-bit blocks is the test’s main focus. The aim of this test is to see if the longest run of ones in the sequence being evaluated is consistent with the longest run of ones that would be anticipated in a random sequence. The rank of the entire sequence’s disjoint submatrices is the rank main concern. This test looks for linear dependency between the original sequence’s fixed-length substrings. The discrete Fourier transform of the sequence’s peak heights is the main emphasis of Fourier. This test’s objective is to find periodic features—repetitive patterns that are close to one another in the tested sequence that would contradict the idea of randomness.

The focus of nonoverlapping templates is the number of occurrences of prespecified target strings. The purpose of this test is to detect generators that output too many occurrences of a given aperiodic pattern. The focus of the overlapping template matching is the number of occurrences of prespecified target streams. Overlapping template matching is concerned with the number of instances of prespecified target streams. In the universal test, the number of bits between matching patterns is measured (this is related to the length of the compressed sequence). The purpose of the test is to detect without loss of information whether or not the stream can be significantly compressed. We can consider a significantly compressible stream to be nonrandom. By using approximate entropy, the frequency of overlapping blocks of two consecutive/adjacent lengths (m and $m+1$) is compared against the expected result for a random sequence. While using serial, the frequency of all possible overlapping m-bit patterns in the entire stream is determined. The goal is to determine whether the number of occurrences of $2m$ m-bit overlapping patterns is approximately the same as expected for a random stream. There is uniformity in random sequences, meaning that every m-bit pattern has the same chance of appearing as every other m-bit pattern. Linear complexity refers to the length of a linear feedback shift register (LFSR). Using this test, we can determine whether the stream is complicated enough to be considered random. Counting the number of cycles with exactly K visits in a cumulative sum random walk is known as random excursion. In a cumulative sum random walk, partial sums are used to transfer a (0, 1) sequence into the correct $(-1,+1)$ stream.

Random excursion variant determines how many times a particular state is visited in a cumulative sum random walk. We use this test to determine how the random walk deviates from the expected number of visits to various states.

The output results for the first 13 tests can be found in

Table 2. NIST test suite results.

NIST Test	p-Value	Success Rate
Frequency	0.028244	1979/2000
Block frequency	0.941144	1982/2000
Cumulative sums forward	0.653773	1979/2000
Cumulative sums reverse	0.335324	1978/2000
Runs	0.288249	1978/2000
Longest run of ones	0.092877	1981/2000
Rank	0.692112	1978/2000
Fourier	0.133788	1975/2000
Nonoverlapping templates	0,477237	1980/2000
Overlapping templates	0.144915	1981/2000
Universal	0.304126	1982/2000
Approximate entropy	0.666245	1979/2000
Serial one	0.138464	1985/2000
Serial two	0.698285	1979/2000
Linear complexity	0.510153	1976/2000

. With the exception of the random excursion variant test, the minimum pass rate for each statistical test is approximately 1966 for a sample size of 2000 byte arrays. For a sample size of 1237 bytes of strings, the random excursion variant test has a minimum pass rate of approximately 1214.

Table 3. NIST random excursion test results.

State	p-Value	Success Rate
−4	0.667562	1228/1237
−3	0.510572	1228/1237
−2	0.998566	1222/1237
−1	0.638812	1224/1237
+1	0.803584	1225/1237
+2	0.758478	1217/1237
+3	0.852332	1226/1237
+4	0.559731	1232/1237

tabulates eight p-values calculated by the random excursion test.

Table 4. NIST random excursion variant test results.

State	p-Value	Success Rate
−9	0.894055	1225/1237
−8	0.343294	1226/1237
−7	0.626963	1226/1237
−6	0.019209	1223/1237
−5	0.460086	1228/1237
−4	0.750448	1226/1237
−3	0.594875	1228/1237
−2	0.331738	1226/1237
−1	0.772760	1226/1237
+1	0.040947	1229/1237
+2	0.593192	1231/1237
+3	0.460086	1227/1237
+4	0.406370	1232/1237
+5	0.368547	1230/1237
+6	0.403493	1233/1237
+7	0.013779	1234/1237
+8	0.122036	1232/1237
+9	0.248871	1225/1237

shows that the random excursion variant test outputs 18 randomness probability numbers: p-values.

From the results in Table 2, Table 3 and Table 4, we see that all the p-values are uniformly distributed over the $(0,1)$ interval. For all the performed tests, the total numbers of acceptable arrays are within the expected confidence levels. Based on this, the novel pseudorandom byte generator passed without error in NIST suite.

The Ent application includes six tests on bit or byte sequences. We tested a stream of 250,000,000 bytes (2,000,000,000 bits) of the decimation-based pseudorandom scheme and tabulated the output data in

Table 5. Ent test results.

Ent Test	Input of Bits	Input of Bytes
Entropy	1.000000	7.999999
Optimum compression	Reduce size by 0%	Reduce size by 0%
${\chi }^2$ square	0.00, exceed 95.29%	241.59, exceed 71.73%
Arithmetic mean value	0.5000	127.5015
Monte Carlo for $\pi$	3.14140229 (error 0.01%)	3.14140229 (error 0.01%)
Serial correlation	−0.000039	−0.000004

. In addition, there are 999,998,680 zero occurrences with fraction 0.499999, and 1,000,001,320 ones with fraction 0.500001. The novel algorithm passed all the Ent tests successfully.

The proposed algorithm has been shown to be of high quality through various statistical tests. To the best of our knowledge, papers using iterative methods and chaotic functions for data encryption are [9,11,16,17,18].

Table 6. Comparison of our proposed symmetric encryption with other schemes.

Encryption Schemes	Key Size	Correlation	Entropy	Arithmetic Mean
Proposed	$2^{256}$	−0.000004	7.999999	127.5015
Stoyanov 2020 [9]	$2^{248}$	−0.000002	7.999999	127.5055
Ali-Pacha 2022 [11]	-	-	7.981570	-
Murillo-Escobar [34]	$2^{128}$	−0.002100	7.994500	-
Hana 2020 [19]	$2^{128}$	-	7.983400	-
AES-128 [35,36]	$2^{128}$	−0.002100	7.954880	127.5281
Stoyanov 2015 [37]	$2^{100}$	0.000001	7.999998	127.4982
Othman 2015 [17]	-	-	7.21	-

provides a summary of the computed values of our proposed scheme in comparison to other algorithms. In [16,18], there is a lack of sufficient statistical data to enrich the comparative analysis.

Based on the positive test outputs and theoretical investigations, we can infer that the proposed readable text encryption based on a numerical method and rotation–translation formula demonstrates satisfactory statistical characteristics and offers a reasonable level of security. From the obtained results, it is confirmed that the new algorithm is not inferior in terms of parameters to the similar techniques indicated in the above tables. The disadvantages of the described algorithm are that in some cases the encrypted text is slightly larger than the input text due to the fact that the output symbols are in complex numbers.

The suggested encryption is dependent on the chaotic system’s initial key parameters and system parameters, which were constructed using the two Zaslavsky equations. If any initial key values change, the encrypted output will be changed significantly; see Column 5 and Column 6 from Table 1. Consequently, the suggested encryption can survive the chosen plain text attack [40].

5. Conclusions

In conclusion, this research has presented an advancement in the field of text encryption, offering a promising avenue for enhancing data security in applications ranging from secure communication to data storage. By amalgamating decimated mathematical equations and polynomial root-finding methods, this innovative approach reveals new horizons for the development of encryption algorithms, with practical and theoretical implications. Our proposed encryption technique is based on a polynomial root-finding method and the output of the Zaslavsky equations. The proposed scheme uses monic polynomials and adds additional randomness by using the decimated Zaslavsky equations. The encryption approach proposed in this paper can be implemented using another chaotic function instead of the Zaslavsky one, such as Lorenz or Rössler equations.

Through extensive experimentation and analysis, we have demonstrated the efficacy and resilience of our method against a spectrum of cryptographic attacks. Our security analysis shows that the novel encryption technique can be successfully used in communication security. As the digital environment continues to evolve and threats to data security persist, approaches based on hybrid techniques open new avenues for encryption techniques with both theoretical reliability and practical utility. The potential implications of this research are profound, promising a more secure and adaptive future for information protection. This study represents a step towards enhancing the confidentiality and integrity of digital information, paving the way for further exploration and refinement in the field of cryptographic methods.

We believe that the areas in which our proposed encryption technique may have application include secure messaging and communication platforms, email encryption, data storage, and IoT (Internet of Things) security. It could also be applied in some key moments in blockchain technologies, such as key management. Blockchain systems rely on cryptographic keys for various purposes, including wallet addresses and transaction signing. Our encryption approach should seamlessly integrate with key management systems. On the other hand, blockchain networks often require fast transaction processing and validation. Encryption methods that are computationally intensive may not be ideal for use within a blockchain network. Efficiency and speed are crucial factors to consider.

In future steps, we want to experiment with encryption-then-compression of readable messages in order to decrease output file size. We also intend to use turbo codes with secret keys to provide high error correction levels. One of our objectives is to implement the proposed algorithm on a reprogrammable integrated circuit.