Understanding and Implementing RSA Algorithm in Python

Understanding and implementing RSA
RSA Algorithm


RSA Algorithm is widely used in secure data transmission. It was invented by Rivest, Shamir, and Adleman in the year 1978 and hence the name is RSA. It is an asymmetric cryptography algorithm which basically means this algorithm works on two different keys i.e. Public Key and Private Key. Here Public key is distributed to everyone while the Private key is kept private.

This algorithm heavily depends on Prime Numbers and their properties. Implementing RSA involves four steps:

  • Key Generation
  • Key Distribution
  • Encryption and
  • Decryption

We will look at each of this operation step by step:

Key Generation

The first phase of RSA is generating a public key and a private key. This is accomplished in several steps:

  • Step 1: The first step is to select two prime number p and q. In order to have strong public and private keys, this primes number should be very large.
  • Step 2: Then we compute ‘n’ which is nothing just product of two prime number we calculated in the above step i.e: n = p * q

‘n’ is used as modules for generating public and private keys.

‘n’ is also released as a part of public key

  • Step 3: Then we compute λ(n) which is Carmichael’s totient function. This is simply calculated using formula:λ(n) = (p – 1) * (q – 1) λ(n) is kept secret.
  • Step 4: Now we calculate e(or encryption key). The way we choose the encryption key is such that the largest common divisor between e and λ(n) is 1 i.e: gcd(e,λ(n)) = 1 or to put it in another word e and λ(n) should be co-prime.

e is released as a part of public key.

  • Step 5: After finding ‘e’ or encryption key using this we calculate decryption key or ‘d’.  The decryption key is calculated such that it is the modular multiplicative inverse of e modulo λ(n) i.e:d ≡ e^(− 1) (mod λ(n)) ‘d’ can be calculated using Extended Euclidean algorithm.

Key Distribution

Suppose that Bob wants to send a piece of information to Alice. To encrypt this information Bob must know the public key of Alice and Alice must use her private key to decrypt the information. Here Alice must transmit her public key (n,e) to Bob. And the encrypted message by the Bob can only be decrypted using Alice’s private key(d).


After obtaining the public key of Alice, Bob now encrypts its message. Bob first converts each character in his message to it’s ASCII equivalent and obtains an integer. This integer is then encrypted using the formula:

c = m^e (mod n)

where c is the ciphertext, m is the ASCII value of the character, e and n are public key pair of Alice.


Alice can recover m from c by using her private key exponent d by computing:

m = c^d (mod n)


First, let’s generate our public key and private key. Open up your text editor and write the following code:

import random

__DEBUG__ = True

def generate(p_num1,p_num2,key_size = 128):
     n = p_num1 * p_num2
     tot = (p_num1 - 1) * (p_num2 - 1)
     e = generatePublicKey(tot,key_size)
     d = generatePrivateKey(e,tot)

    if __DEBUG__ == True:
       print(f"n = {n}" )
       print(f"tot = {tot}")
       print(f"e = {e}" )
       print(f"d = {d}" )

    return e,d,n

def generatePublicKey(tot,key_size):
     e = random.randint(2**(key_size-1),2**key_size - 1)
     g = gcd(e,tot)
     while g != 1:
         e = random.randint(2**(key_size-1),2**key_size - 1)
         g = gcd(e,tot)

     return e

def generatePrivateKey(e,tot):
     d = egcd(e,tot)[1]
     d = d % tot
     if d < 0 :
         d += tot
     return d

def egcd(a,b):
     if a == 0:
         return (b, 0, 1)
         g, y, x = egcd(b % a, a)

     return (g, x - (b // a) * y, y)

def gcd(e,tot):
     temp = 0
     while True:
         temp = e % tot
         if temp == 0:
             return tot
         e = tot
         tot = temp

def isPrime(num):
     if num < 2 : return False
     if num == 2 : return True
     if num & 0x01 == 0 : return False
     n = int(num ** 0.5 )
     for i in range(3,n,2):
         if num % i == 0:
             return False

     return True

Here generate function takes three arguments which are two prime number and one is the size of the key. Here I have taken the size of the key to be 128 bit long.

Next, we calculate ‘n’ and Carmichael’s totient function(i.e tot) which is straight forward.

Then we calculate our ‘e’ and ‘d’. The way I have calculated ‘e’ key is:

  • First I have chosen a random number which is 128 bit long.
  • Then I check whether the generated number e and tot has the greatest common divisor(gcd) is equal to 1. If it is 1 we have found our e if not go to step above.

For calculating d I have used extended euclidean distance algorithm. Now I will not go into the math part as it is not the concern of this article but if you want to know how this algorithm work you can refer to this article.

Now we have our e,d and n.Next we write our encrypt and decrypt function:

def encrypt(text,e,n):
     ctext = [pow(ord(char),e,n) for char in text]
     return ctext

def decrypt(ctext,d,n):
         text = [chr(pow(char,d,n)) for char in ctext]
         return "".join(text)
     except TypeError as e:

As I have explained in encrypt function first we convert each character of plain text to it’s ASCII equivalent the we calculate the cipher text using formula: c = m^e (mod n) which is what we have done. In decrypt function we do the reverse we first decrypt the message using the private key with formula:

m = c^d (mod n)

which gives us ASCII value then we convert this back to its character equivalent.

That’s all we have written our RSA algorithm. Now let’s test our algorithm write the following code:

def getPrime(limit = PRIME_LIMIT):
     num = 0
     while True:
         num = random.randint(0,limit)
         if isPrime(num):
     if __DEBUG__ == True:
         print(f"Generated Prime number: {num}")
     return num

PRIME_LIMIT = 1000000000000

if __name__ == '__main__':
     e,d,n = generate(getPrime(),getPrime())
     plainText = "This is plain Text"
     cipher = encrypt(plainText,e,n)
     dicipher = decrypt(cipher,d,n)

Run the above program and you will see every time new keys are generated and it encrypt and decrypt our plainText



Now let’s try to stimulate RSA process. I have written a python scripts which will help us to run this stimulation. First, create a new file as main.py and write the following code:

# main.py

#! /usr/bin/bash

import sys
from rsa import *

def printHelp():
     print("Usage: \nmain.py -g")
     print("main.py -e inputFile -o ouputFile -k publicKey")
     print("main.py -d inputFile -o ouputFile ")
     print("-g,--generate : To generate public key and private key")
     print("-e,--encrypt : Encrypt")
     print("-i,--input : Input file")
     print("-k,--key : public key file")

def generateKeys():
 ## Generating Keys
     e,d,n = generate(getPrime(),getPrime(),key_size = 128)
     print("Keys Generated")
def Encrypt(public_key,text_file):
     text = ""
     e = 0
     n = 0

 ## Reading public key
     with open(public_key,'r') as fp:
         _,e,n = fp.readline(),int(fp.readline()),int(fp.readline())

     with open(text_file,'r') as fp:
         text = fp.read()
     cipher_text = encrypt(text,e,n)

     with open("encrypted.txt",'w') as fp:
     for i in cipher_text:
     print("File Encrypted")

def Decrypt(text_file):
     e = 0
     n = 0
     cipher_text = []

 ## Reading private Key
     with open('private.key','r') as fp:
         _,d,n = fp.readline(),int(fp.readline()),int(fp.readline())

     with open(text_file,'r') as fp:
         cipher_text = [ int(i) for i in fp.readlines()]

     original_message = decrypt(cipher_text,d,n)
     with open("decrypted.txt",'w') as fp:
         for ch in original_message:

     print("File Decrypted")

if __name__ == '__main__':
     if len(sys.argv) <= 1:
         public_key = ""
         text_file = ""
         keyFile = ""
         outputFile = ""
         gen = False
         enc = False
         dec = False
         i = 1
         while i != len(sys.argv):
             if sys.argv[i] == '-g' or sys.argv[i] == '--generate':
                 gen = True
                 i += 1
             elif sys.argv[i] == '-e' or sys.argv[i] == '--encrypt':
                 enc = True
                 i += 1
             elif sys.argv[i] == '-d' or sys.argv[i] == '--decrypt':
                 dec = True
                 i += 1
             elif sys.argv[i] == '-i' or sys.argv[i] == '--input':
                 i += 1
                 text_file = sys.argv[i]
             elif sys.argv[i] == '-o' or sys.argv[i] == '--output':
                 i += 1
                 outputFile = sys.argv[i]
             elif sys.argv[i] == '-k' or sys.argv[i] == '--key' :
                 i += 1
                 public_key = sys.argv[i]
                 i += 1

         if gen == True:
         elif enc == True:
             if public_key == "" or text_file == "" :
         elif dec == True:
             if text_file == "":

Now create two directories, Alice and Bob, for two-person. Now go to each directory and run the following command as:

 python main.py -g

This will generate private and public keys for each person in each directory. Now suppose Bob wants to send a message to Alice. The message is “Hello world” and which is stored in the file name file.txt. So Bob will need the public key of Alice to encrypt the file which we have just generated in Alice directory. Type following command to encrypt the file

python main.py -e -i file.txt -k ../Alice/public.key

Notice that here I have use Alice’s public key to encrypt the file

This command will generate encrypted.txt file. Now copy this generated file to Alice’s directory.To decrypt this file run the following command:

 python main.py -d -i encrypted.txt

This will create decrypted.txt file which will contain Bob’s original message which is ‘Hello world’.



Sharing is caring!

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top