Hi Dears, according to implementation RSA in python. I found that if p and q large.
the decryption phase takes a lot of time to execute.
for example, in this code i select p=23099, q=23059, message=3
it takes 26 minute it decrypts the encrypted message.!
So I wonderful how we can select to large prime number for RSA, while it cannot execute in desired time. !
So, I think that we cannot use RSA i n real time systems.
Are you agree with me?
the source code is:
from math import gcd
import time
# defining a function to perform RSA approch
def RSA(p: int, q: int, message: int):
# calculating n
n = p * q
print(n)
# calculating totient, t
t = (p - 1) * (q - 1)
start = time.time()
# selecting public key, e
for i in range(2,t):
if gcd(i, t) == 1:
e = i
break
print("eeeeeeeeeeeeee",e)
# selecting private key, d
j = 0
while True:
if (j * e) % t == 1:
d = j
break
j += 1
print("dddddddddddddddd",d)
end = time.time()
# print(end-start)
e=0
#RSA(p=7, q=17, message=3)
RSA(p=23099, q=23059, message=3)
d=106518737
n=532639841
e=5
#RSA(p=23099, q=23059, message=3)
start= time.time()
ct=(3 ** e) % n
print(ct)
pt=(ct ** d) % n
end = time.time()
print(end-start)
print(pt)
#----------------------------------------------------
the code is not the right way to implement the RSA algorithm, actually, the decrption time is less than 1s, it's ms level.
Dear Dr Qingkuan Dong
thank for your contribution, i found that, you mean to implement it at the machine level? Or to be designed as hardware. OK??
Find out what happens under the hood in python. The pt=(ct ** d) % n looks suspect. In practical implementations of RSA, there are optimizations for a modular exponentiation. Even when implemented directly (C + assembler) on a 100 MHz CPU, a realistic modulus size of > 2000 bit takes hundreds of ms.
Hi Mohammad,
If you're using Python, I'd suggest using pow(ct, d, n) instead of pt=(ct ** d) % n. That should improve the time. As Wim suggests, modular exponentiation improves the running time of large exponents.
Cheers
It is true that when using large prime numbers for RSA encryption, the decryption phase can become computationally intensive and time-consuming, especially for extremely large primes. In your example where you selected p=23099, q=23059, and a message of 3, the decryption process took 26 minutes to execute. This can indeed be impractical for real-time systems where quick decryption is essential.
One way to address this issue is to optimize the RSA implementation by using more efficient algorithms for key generation and decryption. Additionally, hardware acceleration and parallel processing techniques can be employed to speed up the decryption process for large prime numbers.
While RSA encryption is widely used for secure communication and data protection, the performance limitations associated with large prime numbers should be taken into consideration when implementing RSA in real-time systems. In some cases, alternative encryption schemes or hybrid encryption approaches may be more suitable for applications where fast encryption and decryption are required.
It's important to evaluate the trade-offs between security and performance when selecting encryption algorithms for specific use cases, considering factors such as computational complexity, key size, and processing speed.
- Badges
- Science topic
- Similar topics
- Computer Communications (Networks)
- Simulators