RSA Cryptosystem Speed Security Enhancement (Hybrid and Parallel Domain Approach)

: Encryption involves every aspect of working with and learning about codes. Over the last 40 years, it has grown in prominence to become a prominent scholarly discipline. Because most interactions now take place online, people require secure means of transmitting sensitive information. Several modern cryptosystems rely on public keys as a crucial component of their architecture. The major purpose of this research is to improve the speed and security of the RSA algorithm. By employing Linear Congruential Generator (LCG) random standards for randomly generating a list of large primes; and by employing other selected algorithms, such as the Chinese Remainder Theorem (CRT) in decryption, exponent selection conditions, the Fast Exponentiation Algorithm for encryption, and finally, a comparison of the enhanced RSA versus the normal RSA algorithm that shows an improvement will be provided.


Introduction
With the use of cryptography, sensitive information may be concealed from prying eyes. The protection provided by urban touchable and physical devices against data access by unauthorized parties is insufficient. Therefore, specialists and developers need to build and extend safety mechanisms to protect data and prevent attacks from starting at such a crucial point. For this reason, "encryption" was borrowed from elsewhere; it is a crucial component of any adequate safety system and a prerequisite for any practical means of influencing or creating such a system. Skill is required to keep the secret from random people. The importance of data encryption over simple message transport is growing as our collective knowledge base expands. Cryptography is used to protect this information, and it may be broadly classified into two subfields: secret-key and public-key cryptography [1].
Today's cryptography relies significantly on the principles of mathematics and computer science. Due to the computational hardness assumptions used in their creation, cryptographic algorithms are very difficult for an adversary to crack in reality. It is conceivable in theory to crack such a system, but doing so in practice is currently impossible. Therefore, we call these methods "computationally and parallel domain approach, the study contribution increases the speed and security of the RSA algorithm.

Organization
This research study is based on the speed and security of the RSA cryptosystem algorithm in hybrid and parallel domain techniques. The paper is broken into sections. The introduction, problem statement, outcomes, and contributions are all included in Part 1. Section 2 addresses the technical background of cryptography; Section 3 examines the literature review, and Section 4 provides an indepth look at the RSA. Section 5 comprises all of the implemented methods and mathematical methodologies for the improved RSA algorithm. Section 6 contains the improved RSA algorithm. Section 7 delves deeper into the results and debate. Finally, Part 8 will summarize the research with recommendations for future work, and the appendix section provides all of the Python codes used for creating our modified RSA and results on GitHub [5].

Background
Cryptography ensures data integrity in information security, providing assurance that data has not been altered with hash algorithms. One other benefit of using digital signatures is that they may be used for non-repudiation or authentication of the parties involved [6], they are two types of cryptography.

Symmetric key cryptography
Symmetric cryptography Figure 1 shows the simplest type of encryption when both parties use the same secret key to encrypt and decrypt data. They are two distinct categories of symmetric key cryptography designated by the quantity of data they are able to process: block ciphers and stream ciphers. The block cipher organizes the input data into blocks or groups of consistent size (within a few bytes), facilitating efficient encryption and decryption, while the stream cipher converts the data format suitable for encryption and decryption. Examples of symmetric encryption algorithms include Blowfish, AES, RC4, DES, RC5, and RC6. One of the primary advantages of symmetric algorithms is their ability to be used in real-time systems, which asymmetric algorithms cannot because each user needs their own unique key.

Asymmetric key cryptography
The use of two distinct keys is at the heart of asymmetric cryptography, commonly known as public-key cryptography. When encrypting plain text with asymmetric encryption, two keys are used a public one that may be shared openly and a private one that shouldn't be revealed under any circumstances. Asymmetric cryptography provides not just the privacy that encryption does but also using digital signatures it is possible to acquire authentication, non-repudiation, and integrity. The context of a signed message is compared to the input used to generate the signature [7]. To counter the fact that anybody in possession of the secret key may read an encrypted communication, asymmetric encryption makes use of a pair of keys that are mathematically connected to one another  RSA, DSA, and Diffie-Hellman are all examples of asymmetric algorithms. Using symmetric cryptography with a straightforward and safe key exchange system enabled by an asymmetric key method makes it possible to have a quick technique that generates compact cipher texts [8].

Related work
Many enhancements were made to the RSA algorithm by many researchers [4]. Some relevant studies are included below: For the hybrid domain, which is the improvement of Classical RSA and one or two additional algorithms. Rebalanced RSA and Multi-Prime RSA were proposed by Boneh and Shacham [9]. A strategy for integrating two previously improved RSA versions was developed by Alison et al. [10]. To increase the security levels and overall execution speed of the method, Gupta and Sharma [11] integrated RSA with the Diffie-Hellman public key cryptographic technique. Based on an additive homomorphic property, Dhakar et al. [12] introduced the MREA (Modified RSA Encryption Algorithm), and they demonstrated that it is far more secure than the regular RSA and extremely resistant to brute force attacks. The RSA and El-Gamal cryptosystems were joined by Ahmed et al. [13] using the Discrete Logarithm Problem (DLP) for El-Gamal and the Integer Factorization Problem (IFP) for RSA. For asymmetric cryptosystems, the pairing of IFP with DLP gave a reasonable processing speed. The El-Gamal and RSA algorithms were less effective than the indicated system computations as a result. In order to secure the upload of data to the cloud, Mahalle and Shahade [14] presented an RSA variation that makes use of the AES method and three keys (a public key, a private key, and a secret key). The authors' conclusion is that this AES-RSA hybrid will effectively give cloud users data security.
In order to make factorization more difficult overall, Arora and Pooja [15] proposed a novel algorithm in 2015. This algorithm uses a hybrid of RSA and the El-Gamal algorithm. AES + RSA and Twofish + RSA, a hybrid implementation of one symmetric algorithm with another asymmetric algorithm, were recently proposed by Jintcharadze and Iavich [16]. They came to the conclusion that RSA + Twofish outperforms the abovementioned hybrid algorithms in terms of speed and memory use. Alamsyah and others [17] to increase the security of two-factor authentication, combined RSA and the one-time pad approach.
For multi-threading or parallel techniques. C. W. Chiou [18] compares a fresh modular exponentiation technique to reduce the time it takes for modular exponentiation to execute in 1993. Because of fewer operations, this method offered a roughly 33% greater throughput. Ayub et al. [19] developed an OpenMP-based parallel CPU-based RSA method implementation that parallelizes the algorithm's exponentiation phase to aid in speedy encryption and decryption. Their analysis concludes that the program's execution time has been improved. Rahat et al. [20] improved efficiency by using a unique parallel data structure termed a Concurrent Indexed List of character blocks in 2019. The essay presented three different simultaneous RSA implementations. With a possible speed-up factor of 4.5.
For the CRT enhancements domain. Wu et al. [21] presented a CRT-RSA in 2001. Their proposal use Montgomery's algorithm rather than CRT, yielding better results for decryption and digital signatures. Blomer et al. [22] presented another CRT-RSA for using CRT to solve fault attack vulnerabilities on RSA-based signature algorithms. According to them, CRT-RSA is widely employed in smart card transactions. Sony et al. [23] proposed using multiple keys and CRT to improve data transmission security by increasing processing time and algorithm security. Quisquater and Couvreur [24] proposed a rapid decryption technique in 1982. Based on previously reported Standard RSA weaknesses, they developed an RSA deciphering method that employs an enhanced modular exponentiation methodology and is based on the CRT, with the goal of increasing overall performance time.
Finally, Aiswarya et al. [25] proposed a novel Binary RSA Encryption Algorithm (BREA) encryption method in 2017. Its security is further increased by converting the encrypted cipher text generated by the Modified RSA Encryption Algorithm (MREA) into binary code format. As a result, the intruder will struggle to decrypt the data. In the same year, Sahu et al. [26] presented a more secure approach than the original by making modulus n private as well.

RSA Algorithm
In 1977, Ron Rivest, Adi Shamir, and Leonard Adleman of the Massachusetts Institute of Technology revealed the public description of the Rivest Shamir Adleman (RSA) algorithm [27]. The system's safety comes from the difficulty of factoring the products of two large prime numbers. This difficulty is the foundation of the one-way RSA core function, which is straightforward to calculate in one direction but prohibitively so in the other. Consequently, RSA is secure since it is mathematically impossible to obtain such numbers or it would take too much time to do so, regardless of the available computing power. In addition, the encryption's safety is directly proportional to the size of the key. An algorithm's effectiveness increases exponentially when its size is doubled. Typical bit lengths for RSA keys are 2048 or 4096.
RSA isn't just used for encryption; it's also the basis for digital signatures, in which only the owner of a private key may "sign" a message, but anybody can check its authenticity using the public key. Several protocols, including SSH, OpenPGP, S/MIME, and SSL/TLS, rely on RSA signature verification [28]. Many firms utilize RSA for personnel verification. Cryptographic techniques are used in chip-based smart cards to ensure security by verifying the PIN code [29]. Pretty Good Privacy (PGP), a freeware that provides encryption and authentication for e-mail and file storage applications, also uses RSA for key transfer.
Furthermore, SSL provides data security by establishing an RSA key exchange during the SSL handshake client-server authentication at the end of the connection between the internet-based communications protocol TCP/IP and application protocols such as HTTP, Telnet, Network News Transfer Protocol (NNTP), or File Transfer Protocol (FTP). The determinism of the original RSA encryption means that the same plain text will always yield the same cipher text when using the same key pair. Due to this feature, the technique is susceptible to a "selected clear text attack," in which an attacker generates cipher texts randomly from a pool of known clear texts and checks whether or not they are equal to previously generated cipher texts. An adversary can learn about the original data without having to decrypt it by making this comparison [3].

Structure of Classical RSA algorithm
 Generate Large Prime numbers p and q.  Calculate modulus N = P · Q.

Implementation of Algorithms
We used many theories and algorithm techniques to improve the total performance of the RSA cryptosystem using our modified RSA algorithm from prime number creation through key generation, encryption, and decryption. All of the approaches applied for the enhancement are listed here.

Linear Congruential Generator
Pseudo-Random Numbers are created deterministically (meaning that they can be replicated) and must look independent, with no visible patterns in the numbers. We utilized this approach to quickly construct a big list of odd integers for a subsequent primality test. The algorithm function's Python code is on my Github [5].
Where Xn is the random integers generated, P1 is the multiplier, P2 is the increment, and m is the modulus, X0 is the initial seed value of the series. As in [29] Linear congruential generator of Equation (1) has a full period (cycle length of m) if and only if the equation meets the following conditions:  gcd(P2, m) = 1;  P1 ≡ 1( mod p));  P1 ≡ 1( mod 4); With m = 2 k , P1 = 4b + 1, P2 as an odd number where (b, k > 0) we will get a full period of length m, for our RSA prime generation approach:  The modulus m should be a known nearest prime from 2 (n+1) , n being the n-bits key, this value is fixed (constant) in our approach.

Miller Rabin Prime Primality testing
The Miller-Rabin primality test [31] is a probabilistic primality test that determines if a particular number is likely to be prime, which is known to be the simplest and quickest test known; this test employs Fermat's Little Theorem [2]. We need to generate two huge prime numbers during the RSA key generation process, and after that, we need to ensure that they are indeed prime. Let us verify "n" primality ⇐⇒ n is an odd number.

Algorithm 1: Miller-Rabin primality test
Find integer k and m such that: n − 1 = 2 k · m Choose randomly any integer a ε [1, n − 1] Compute b0 = a m mod n Compute bi,"k" times, bi = −1 2 mod n The result must be ±1: If the solution is 1, n is a composite number and if the solution is -1, n is a prime number. Repeat the test "i" times. The probability of a composite n passing "i" tests is 1/4i; for our implementation the probability is 2 −128 . GitHub repository [5] has a Python code of this algorithm.

Extended Euclidean algorithm
Euclid's algorithm if gcd (a, b) = d, then there exist integers x, y such that ax + by = d. The first step in the Euclidean method is to divide the bigger integer, a, by the smaller number, b, to get the quotient, q1, and the remainder, r1(less than b), a = q1b + r1 Next, we'll use b and r1 to go on in the same manner, eventually arriving at the value: b = q2r1 + r2 rn−2 = qnrn−1 + rn Finding the largest common divisor is complete after we have achieved rn|rn−1. This is shown by the evidence below: After solving for rn −2 = qnrn−1 + rn, in the previous step, we arrive at the following equation: rn −2 = qnrn − 1 + rn Now, suppose d is the gcd of a and b. So we get <d|a and d|b>. Hence, we get rn as the Greatest Common Divisor (gcd) of a and b.

Fermat's Little Theorem
Fermat's Little Theorem Let a ∈ N and p be a prime number, then: a p ≡ a mod p (6) a p−1 ≡ 1 mod p (7)

CRT Chinese Remainder Theorem
A system of two or more linear congruencies does not necessarily have a solution, even though each of the individual congruencies does [33]. The Chinese Remainder Theorem CRT describes the solutions for a system of simultaneous linear congruencies.
x ≡ a mod m and x ≡ b mod n have a unique solution if the modules are relatively prime to each other, two to two. Where gcd (m, n) = 1.

Fast Exponentiation Algorithm
The speed with which we can calculate M e (mod N) for integer n of this magnitude is a significant aspect of public-key cryptography. The integers used in modern RSA keys are at least 1024 bits long.
The traditional method for raising to a power, say x 8 is as follows: x ⃗⃗⃗⃗⃗⃗⃗⃗ x 2 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 3 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 4 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 5 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 6 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 7 ⃗⃗⃗⃗⃗⃗⃗⃗⃗ x 8 Where Sqr means squaring and Mul means multiplying. We squared first, followed by six successive multiplications, a total of seven operations. In RSA, we would have to execute 21024 multiplications for a power of 1024 bits, which is not at all convenient. The square and multiply algorithm is the fastest way to perform this exponentiation.
Consider the same example shown above to calculate x 8 using square and multiply algorithm: x ⃗⃗⃗⃗⃗⃗⃗⃗ x 2 ⃗⃗⃗⃗⃗⃗⃗⃗ x 4 ⃗⃗⃗⃗⃗⃗⃗⃗ x 8 We only need 3 squaring operations, note that the square and multiplication operation has the same time complexity.
To know the number of squaring and multiplying operations required we convert the exponent to its binary equivalent, where we have "1" we square and multiply in that order, and where we have "0" we apply square operation only, This method is called the Fast exponentiation algorithm [34]. See Algorithm [3].

Recommendations to select the value "e"
We recommended using a very small public key value "e" less than√Φ (n). Therefore the trap Φ(n) = (p − 1)(q − 1), p and q being primes of at least 1024 bits, and the size of Φ(n) will be approximately equal to that of n, a little smaller but with the same magnitude(number of bits). Since the public key "e" and the private key "d" are inverses in the field Φ (n), that is, d = inv [e, Φ (n)] then we get the following relation e· d (mod Φ (n)) = 1, for this equality to hold, the product "e· d" must leave the field Φ (n) at least once so that the operation in that module returns the value 1. In other words, it will be true that e· d = k· Φ (n) + 1, with k = 1, 2, 3, 4...
For this product to come out at least once from the body Φ (n), that is with k = 1, given that the public key "e" has for example 17 bits, the value of the private key d should be at least greater than 1007 bits, for the hypothetical case (and with almost null probability) that the equation is fulfilled for k = 1. In practice, that value of k = 1 or a low value of k, will be very unlikely and, therefore, we can expect a private key "d" very close to or equal in bits to the value of n as it happens in the practice. In other words, it will be computationally difficult to guess the value of the private key d, since finding a number within a 1024-bit body means an intractable computation time, with an average of 21023 attempts [35]. Forcing then the public key e to being a small value, less than 20 bits within a body of 1024 bits or greater guarantees that the private key d is a very large value and, therefore very secure since it is computationally intractable to find it by brute force.
In our model, we will choose value "e" from Fermat's numbers less than√Φ (n), and since all Fermat's numbers are prime numbers we won't necessarily need to check if gcd(e, ϕ(n)) = 1 which saves time. This relatively small value of "e" forces the private key "d" to have a size similar to the modulus n and makes a brute force attack impractical. For example the value 65537 a known prime number as Fermat number (F4) was used to create the SSL certificates See Figure 3.
[Fermat's prime] Fn = 2 2 In addition to the advantages mentioned, Fermat primes such as F4 have a significant feature that is worth highlighting. The binary representation of F4 has only two one bits equal to 65, 53710 = 100000000000000012 = 01000116. This fact has great utility in exponentiation computational efficiency.

Paired private and public keys
When an RSA key is generated, Euler's thotient function Φ (N) is used as a trap to calculate the private key "d" knowing the public key "e". Since (e, Φ(N)) = 1, it is guaranteed that the inverse "d" exists and that it is the only inverse of "e" in that field Φ(N). The encryption is done afterward in the public body N so that anyone can use it. And in said body N it is no longer satisfied that the only inverse of the public key "e" is the private key "d". There is at least one other value other than a "d" that allows deciphering what is encrypted with the public key.
These keys are called paired private keys. It has been said that an asymmetric cipher system has a single public key, and therefore also a single private key. For the RSA cryptosystem, this has turned out to be false. An example will better illustrate this. That is, for the ciphered body N = 2109 with public key e = 13, the numbers 349, 853, and 1357 are paired private keys d0 that fulfill my function more than the private key d. Every RSA key will have at least one matching private key. The number of even private keys depends strongly on the primes P and Q.

Unencryptable messages
One of the security vulnerabilities are non-recommended keys that either do not encrypt the information to protect or do so in a predictable way. For example, in the symmetric algorithm DES (Data Encryption Standard), there were weak or semi-weak keys, which did not satisfy the singledigit principle enunciated by Shannon; and gave solutions known as false solutions. Something similar happens in RSA, where there are unencryptable messages, or rather, unencryptable numbers.
0 key mod N = 0 and 1 key mod N = 1 (10) Another value that is transmitted in the clear is (n -1), since: Example: Consider the RSA key with n = 17 · 29 = 493 and e = 11, we have: In addition to these three numbers, in RSA there will always be another 6 numbers that are not encrypted.on our example: To locate these unencryptable numbers requires a brute force encryption attack on the space of the primes p and q, to verify the values of X that yield the following inequalities: X e (mod P) = X and X e (mod Q) = X for 1 < X < Q -1, P-1 Keys of 1024 bits or more make calculations within the primes p and q computationally intractable if each has at least 512 bits. Therefore, for those keys, it will not be possible to find the remaining unencryptable numbers. The equations to calculate the unencryptable numbers are shown below: The number of unencryptable numbers σn within a field n is: The unencryptable numbers will be: N = [q· (inv (q, p)) · Np + p· (inv (p, q)) · Nq] mod n (13) Where: Np are the solutions of N e mod p = N and Nq are the solutions of N e mod q = N As can be seen, the only complicated calculation that occurs is in the last two equations, which means attacking by brute force all values of N candidates to be non-cipherable numbers, with 1 < N < (P − 1) for prime P and 1 < N < (Q − 1) for prime Q

Optimised RSA algorithm
For our modified RSA, we drew the following conclusions concerning the sizes of the operands:  Carefully select the prime numbers p and q such that factoring them would be computationally unfeasible. As a rule of thumb, the bit lengths of these primes should be roughly comparable. For example, if the number n is 1024 bits in length, then the appropriate sizes for p and q are approximately 512 bits.
 The exponent is typically small in order to maximize the power of the exponentiation.

RSA Modified
 Generate Large Prime numbers p and q generate truly unpredictable random numbers list using LCG Section 5.1, then tests for primality we used Rabin-Miller probabilistic test Section 5.2.
 Calculate modulus N = P · Q  Calculate X to replace N. X = N − (P + Q) The key length, which is commonly stated in bits, determines its size. We recommended the Karatsuba algorithm Section 5.3 for N computation. The Karatsuba approach begins to pay off as ndigits increase, as it can multiply hundreds of digits quicker than the standard technique.
 Calculate Euler's totient function, which is defined as: Φ(N) = X + 1 Reduced multiplication of (P-1) (  Decryption Plain-Text message M = C d (mod N) We proposed to use CRT Section 5.6 and Fermat's Little Theorem 5.6 for fast computation and monitoring security.

RSA Modified Example
We begin by walking over on how to generate RSA encryption and decryption keys. After that, we'll go through a basic example to see how encryption and decryption work in practice.
 Two prime numbers "P" and "Q" are chosen. At present, such numbers must be of the order of 1024 bits, at least. For our example, Let us use a 16-bits prime for illustration n_digits = 16 log 2 = 5 Using Equation (5)   A fermat's value of "e < 39733" is chosen. We will take Fermat number three. e = F3 = 2 2 3 + 1 = 257 < 39733 , since all Fermat's numbers are primes therefore gcd (257, 1578717360) = 1.  Calculate d, the multiplicative inverse of module n. Since gcd (e, Φ(n)) = 1, we will apply Extended Euclidian algorithm [1] to express 1 as a linear combination of integer u and v such that: Equation [14] into [15] we Step 1: First compute the binary representation of the exponent "257". 25710 = 1000000012 Step 2: Read the binary representation of the exponent from left to right. 1000000012 = b0b1b2b3b4b5b6b7b8 Step 3: For every subsequent bi = 1 apply square and multiplication while every subsequent bi = 0 we apply the square operation only.
This completes the encryption process See Compute: (6851 · 67699 · 9075) + (55757 · 23321 · 41355) = 57983316650610 mod (23321 · 67699) = 123456 Plain-text message M = 123456 as expected.  We also want to look into the temporal complexity of each method. In this situation, we're interested in the algorithm's efficiency, or how long it takes the function to generate at least two prime integers. As shown in Table 2, traditional prime generation always yields a single prime number by randomly selecting an odd number and testing for primality, however, our suggested LCG prime generation method yields a list of primes in a short time. Figure 4 illustrates a graph.

Key Generation
Consider n as the number of bits of P or Q both prime and N as the product of P and Q.

Modulus computation
The time complexity to compute the modulus N product of two big primes P and Q of the same bit size is ( 2 ) 2 using big O-natation that is O (n 2 ). By using the Karatsuba algorithm Section [5.3] the time complexity goes down to O (n 2 3 ) approximately O (n 1.58 ).

Thotient computation
The time complexity to compute Φ (N) product of two large integers (P − 1) and (Q − 1) of the same bit size is ( 2 ) 2 using big O-natation that is O (n 2 ), by substituting X = N − (P + Q), Φ (N) = X + 1 the time complexity goes down to O (n)

Making the exponent smaller vs Classical RSA
In making an algorithm faster, we can actually use a small exponent and still RSA will be secure, In Table 3 changing the public key exponent e to the binary representation we can tell the number of operations that are required for the square multiply algorithm using exponentiation, fast encryption is possible using this small exponent and RSA is still secure for short.  The public exponent "e" can be smaller in this case, but "d" must be as big as "N" now, thus we applied the Chinese remainder theorem (CRT) to accelerate decryption. This technique lowers n_bits modular exponentiation into two n/2_bits modular exponentiations plus the CRT steps described above, while P −1 can be precomputed and saved. The Chinese remainder theorem, according to Table  4, is substantially faster at the expense of system parameters and memory, and it does not require any modular inversion implementation, saving development costs and memory. As illustrated in Figure  6, 7 and 8 both the CRT and decreasing the exponent need less processing time than the standard RSA. Because it adds randomness to the cryptography method, RSA's improved performance increases speed and security.

Comparison of Total Time Complexity
The time complexity study of the enhanced RSA method and the traditional RSA algorithm will now be described using big O notation. For time complexity operations, we have the following features, as described by [36] and [37]: Sum (x + y), the sum of two n-bit values has a time complexity of O (n). Subtraction (x -y), is an addition of a negative integer, its asymptotic time complexity is O (n).
Multiplication (x * y), the product of two n-bit values, has a time complexity of O (n 2 ). Division (x / y), is a multiplication of an inverted integer, its asymptotic time complexity is O (n 2 ). Module (A mod N), given an n-bit A, the algorithm's time complexity is O (n 2 ). Exponentiation in modules (A B mod N) has a time complexity of O (n 3 ). The Extended Euclid's Algorithm, Using the gcd (a, b) = gcd (b, a mod b) rule, Euclid's method computes the gcd of two integers a and b and yields the last value of "a" as gcd when b is zero. To examine the Extended Euclid's algorithm, assume a and b of n-bits, and a mod b < a/2 at each iteration. As a result, the algorithm will only make n recursive calls (since each division decreases one bit of n). In addition, a division of complexity O (n 2 ) is done at every recursive step to extract the new argument b for the following iteration. When we add up the whole time, we obtain. O (n) · O (n 2 ) = O (n 3 ) Multiplicative Inverse, Time complexity is O (n 3 ) due to the usage of the Extended Euclid method. Primality Test, the N key is n bits long, while the prime integer p is (n/2) bits long. In practice, the primality test is performed using the probabilistic Miller-Rabin test, Algorithm [5.2]. The most expensive operation in the Miller-Rabbin technique, given a number p of n bits, is modular exponentiation, which has an O (n 3 ) complexity. Furthermore, to ensure a high level of confidence, this test is repeated about ln (p) / 2 [38], resulting in a complexity of O(n). As a result, the final complexity is O (n 3 ) · O (n) = O (n 4 )  We can examine the overall RSA performance in contrast to the suggested RSA from all of the above time complexity properties, as presented in Table 5.

Conclusion
This study proved helpful with a combination of the Chinese Remainder Theorem (CRT) algorithm, Fast exponentiation Algorithm, small exponent, and Linear Congruential Generator (LCG) that has been proposed with the normal RSA algorithm for fast and secure communication for large data. We applied the proposed theorems, multiplication algorithms, and randomness techniques to redesign the execution of the RSA cryptosystem that improves speed on the RSA encryption side while the security of data was maintained and upgraded with the CRT on the decryption side. This research objective includes a detailed overview of the most successful classical cryptographic Technique RSA. The study proposed an RSA with the Chinese Remainder Theorem using a small value of the exponent, which helped enhance the cryptographic algorithm. Another contribution is the discussion on different multiplication algorithms and their pseudo-codes. Future work will discuss the practical implementation of the modified RSA algorithm's security attacks and threats. But unless we encounter a situation that puts our data in danger, we will continue to use what we have.