RC4 is well described in Wikipedia, and only a very brief summary is presented here as the basis for subsequent descussions.

Description of RC4

RC4 consists of the following components

• The S array, usually with 256 values (0 to 255) to represent all possible values of a byte. The values are arranged using the password, and so are specific to the password
• The Pseudo Random Generation Algorithm (PRGA). This is a method of selecting the value from the S array to encode (encrypt or decrypt) the incoming data. A feature of this method is that the values are not accessed sequentially from the array, but each value determines the next value to be accessed.
• Encoding is by the "exclusive or" (xor) operation between the value from the S array and the data. This means that encrytion and decrypting uses the same process. This makes the algorithm simple, but it requires the same password being used for both processes (symmetrical key)

As the arrangements of the S array depends on the password, and the sequence of access depends on the arrangements of the array, encryption proceeds in a deterministic manner, but unpredictable unless the password is known. RC4 was therefore described as symmetric key, streamable, fast, and secure.

Vulnerability of RC4

When RC4 became available in the late 1980s, it was rapidly incorporated into many applications, and for encrypting messages to send over the Internet. After a few years of extensive use however, a vulnerability in RC4 was discovered.

Although RC4 remains secure if the password is used only once, repeated use of the same password was found to be vulnerable, for the following sequence of reasons

1. The relationship between the plain text and cipher text depends on the password.
2. This relationship is invariant. The same plain text and the same password will produce the same ciphertext
3. By analysing many messages using the same passwords, a pattern of relationship can be found
4. By statistically exploring this relationship, the password can be revealed
5. Once the password is known, all messages encrypted with that password become transparent.

Because of this vulnerability, RC4 is no longer commonly used to encrypt messages for electronic communications.

Although there are many more secure encryption algorithms available, RC4 remains an important encryption method because it is a stream cipher that is low cost, simple and fast, and it can be embedded easily into other applications without licence or complex APIs. Repeated modifications of the basic RC4 algorithms have therefore been made as attempts to address this vulnerability (see Wikipedia).

Password: Key board characters of any length, to be used for both encryption and decrypting MyPassword Plain Text: Text consisting of keyboard characters to be encrypted The quick brown fox jumps over the lazy dog      Cipher Text: Characters 0-9 and a-f or A-F representing Hex values of encrypted cipher text

Replace default example password and text with user's own. Note password is for both to encrypt and to decrypt

• The top text area contains the password. The same password is used to both encrypt and decrypt
• The second text area contains the plain text and the third text area the cipher text
• On clicking the Encrypt button, the program encrypts the plain text and place the result in the cipher text area
• On clicking the decrypt button the program deceypts the cipher text and places the results in the plain text area
• The text areas contains default example password and plain text. Users should replace these with this/her own
• The program uses Javascript and runs on the user's computer. Not information is transmitted to the server
• The program code is in the source code of the page, and can be viewed and copied

I had difficulties finding a Python library for the basic RC4 algorithm, probably because the algorithm is so simple nobody bothered to create one. The only one I found was in the package Cryptography, and it is ARC4 for Alleged RC4. It adds a nonce, a string of random numbers to both the key and to the plain text, to disrupt the pattern of the cipher text, making it more difficult to hack. However, I could not make it work, as I have an incomplete understanding of the hash functions involved. The original code, copied from https://pycryptodome.readthedocs.io/en/latest/src/cipher/arc4.html is as follows

# -*- coding: utf-8 -*-

>>> from Crypto.Cipher import ARC4
>>> from Crypto.Hash import SHA
>>> from Crypto.Random import get_random_bytes
>>> from Crypto.Cipher import ARC4
>>> from Crypto.Hash import SHA
>>> from Crypto.Random import get_random_bytes
>>>
>>> key = b'Very long and confidential key'
>>> nonce = get_random_bytes(16)
>>> tempkey = SHA.new(key+nonce).digest()
>>> cipher = ARC4.new(tempkey)
>>> msg = nonce + cipher.encrypt(b'Open the pod bay doors, HAL')

However, I used the ARC4 library, excluded the nonce, and built some subroutines to handle input and output as text strings, and produced the same results as the Javascript and the Python plain code programs. This algorithm is therefore a short cut, but mostly a validation of the other two programs which I constructed

Th code is as follows

from Crypto.Cipher import ARC4 #Crypto is in package cryptography

class MyRC4:
    """ class to do standard RC4 """
    key = None
    def Init(self, pw):
        """ initialize password into byte key  """
        self.key = pw.encode()
    def Encrypt(self, pw, plainText):
        """ encrypt plain text string using password pw """
        self.Init(pw)                  # creates key from password
        myrc4 = ARC4.new(self.key)     # calls ARC4 from crypto
        ct = myrc4.encrypt(plainText)  # cipher ct as byte object
        ctHex = ct.hex()               # cipher as a hex string
        return ctHex
    def Decipher(self, pw, cipherText):
        """decipher hex string cipherText using password pw """
        self.Init(pw)                  # creates key from password
        myrc4 = ARC4.new(self.key)     # calls ARC4 from crypto
        ct = bytes.fromhex(cipherText) # convert cipher hex string byte objects
        pt = myrc4.decrypt(ct)         # plain as byte object
        pt = pt.decode()               # decode to plain text
        return pt
    
       
if __name__ == "__main__":
    """ Testing """
    rc4 = MyRC4()
    pw = "MyPassword"
    plainText = "The quick brown fox jumps over the lazy dog"
    cipherText = rc4.Encrypt(pw, plainText)
    print(cipherText)
    plainText = rc4.Decipher(pw,cipherText)
    print(plainText)

Results from testing

d8ff380d3055f42c4d6681bce14b63a595752d3a541aa6974c34138e67233d014cc0fcadb461354af1222f
The quick brown fox jumps over the lazy dog

The code presented in this panel is a direct translation of the Javascript ptogram in the earlier panel.

# -*- coding: utf-8 -*-
    
class RC4:
    """
from source code from Github:
    farhadi / rc4.js in Instantly share code, notes, and snippets.
    https://gist.github.com/farhadi/2185197
    """
    def __init__(self):# class variable
        self.sAr = []  # the S array for rc4
        self.ii = 0    # array indeces
        self.jj = 0
        
    """ 
    shuffles array with a list of bytes of any length
    """
    def ShuffleSArray(self, keyAr):
        leng = len(keyAr)           # length of keyAr
        lengthOfCycle = 256         # set length to sAr at 256
        if(leng>256):
            lengthOfCycle = leng   # change to len if len greater
        j = 0
        for i in range(lengthOfCycle):
            si = i%256             # index of S array
            ki = i%leng            # index of key array
            j = (j + self.sAr[si] + keyAr[ki]) % 256
            x = self.sAr[si]
            self.sAr[si] = self.sAr[j]
            self.sAr[j] = x
            
    """ Changes the s array with password """
    def SetPassword(self, password):
        """ creates the S array with string passwords """
        """ fill initial S array """
        self.sAr = [n for n in range(256)]
        """ convert password to key array of bytes """
        keyAr = []
        for i in range(len(password)):
            keyAr.append(ord(password[i]))
        """ shuffles S array and reset keys """
        self.ShuffleSArray(keyAr) 
        self.ii = 0
        self.jj = 0
        
    """ Get the next byte from S array 
        uses the Pseudo-random generation algorithm (PRGA) 
    """
    def GetNextCipher(self):
        self.ii = (self.ii + 1) % 256
        self.jj = (self.jj + self.sAr[self.ii]) % 256
        tmp = self.sAr[self.ii]
        self.sAr[self.ii] = self.sAr[self.jj]
        self.sAr[self.jj] = tmp
        tmp = (self.sAr[self.ii] + self.sAr[self.jj]) % 256
        return self.sAr[tmp]

    def DecToHex(self, i, c):
        """ decimal to hex : i=integer, c=number of character """
        fStr = '{:0' + str(c) + 'x}'
        return fStr.format(i)

    def DecipherByte(self,txt,i):
        h = int(txt[i:i+2],16) # hex -> byte
        return h ^ self.GetNextCipher()  # decipher byte
    
    def RC4_Encrypt(self, plainText, password):
        """ encrypt plainText with password """
        # creates the S array and set ii
        self.SetPassword(password)
        cipherText = ""
        for i in range(len(plainText)):
            a = ord(plainText[i])             # character -> byte
            e = a ^ self.GetNextCipher()      # encrypted byte
            cipherText += self.DecToHex(e,2) # append to cipherText
        return cipherText

    def RC4_Decipher(self, cipherText, password):
        """ decipher cipherText with password """
        self.SetPassword(password)        # creates the S array and set ii
        plainText = ""
        i = 0
        while(ichr, add to plainText
            i += 2
        return plainText
"""  end class RC4 """
def RC4Encrypt(plainText, password):
    rc4 = RC4()
    return rc4.RC4_Encrypt(plainText, password)
    
def RC4Decipher(cipherText, password):
    rc4 = RC4()
    return rc4.RC4_Decipher(cipherText, password)
    
if __name__ == "__main__":
    """ Testing """ 
    ps = "The quick brown fox jumps over the lazy dog"
    print(ps)
    pw = "MyPasswordc"
    print(pw)
    cs = RC4Encrypt(ps,pw)
    print(cs)
    ds = RC4Decipher(cs, pw)
    print(ds)
    
    print(ps)
    print(pw)
    cs = RC4PlusEncrypt(ps,pw)
    print(cs)
    ds = RC4PlusDecipher(cs, pw)
    print(ds)

Results of testing. Note: RC4Plus produces different cipher text each time even with the same password and plain text

The quick brown fox jumps over the lazy dog
MyPasswordc
67bcbe17291c68e9ae3fd2acebad9747b8f8ab1f3505ee3d84eb943be2aac8e2449d065f92111dc1d5c34a
The quick brown fox jumps over the lazy dog

AES is widely and clearly described on the www, examples of which are that by Wikipedia and this tutorial. This panel will therefore provide only a brief summary, as a basis for understanding the program and how to use it.

AES is currently (2021) accepted as the standard symmetrical key encryption, and the 128 bit key is considered unbreakable using current computer power. The program takes blocks of 16 bytes from the plain data, and shuffle it in a way that is controlled by the key. The result cipher is a combination of the key and the original information. The original information can be decrypted from the cipher using the same key in a reverse process.

Currently AES is widely ditributed commercially. It is accepted by the US military, and included in the password protection of Microsoft Office documents, pdf, and Winzip.

All 3 programs are modifications of the originals that I have found on the www. They all work, but produces different cypher text.

• The javascript is the most basic. It allows 128, 192, and 256 bits encryption. The advantage of using this is that there is no requirements of preliminery set up. The program is ready to run on the web page. The disadvantage is that Javascript is too slow to handle large files
• The Python program using the Cryptography library will also do 3 levels of encryption. The advantage is that the program is short (to the user), and runs super fast. The disadvantage is that all the codes are hidden so the process is opacque
• The Python program using native Python can only do 128 bits encryption. However the program pads that passowrd and the plain text with random data, so greatly strengthens the encryption. It seems to be the most secure of the 3 versions, but it is also too slow to encrypt large amount of data.

All 3 programs uses text strings for plain text and password, and produces hex string as cipher text. Although the input output formats are similar, the 3 programs uses different paddings and tables, so that cipher text produced by one cannot be decripted by the others.

Key Size: 16 chrs (128 bits) 24 chrs (192 bits) 32 chrs (256 bits)	- Click to choose - Recommended and default value = 128 bits
Password: ThisIsMyPassword	- Key board characters, up to 16 chrs for 128 bits,    up to 24 chrs for 192 bits, up to 32 chrs for 256 bits
Plain Text: The quick brown fox jumps over the lazy dog	- Text of keyboard characters to be encrypted - Result cipher text in hex placed in Cipher Text area
Cipher Text in Hex:	- Hex characters (0-9 and a-f or A-F) - Each 2 hex represents a byte - Result decrypted text of chrs placed in Plain Text area

Key Size of 128 bits considered secure enough by NSA of USA. Larger keys are not really necessary, but presented because the source code provided for it

Password can be any length. If too short, program will expand it by repeating the input. If too long the excess will be discarded.

Default Examples can be replaced by user's own choice

The original Javascript source code was downloaded from http://point-at-infinity.org/jsaes/jsaes.js, and this web based user interface added.

There are many AES libraries in Python, with varying degrees of sophistication and complexity. I have chosen this particular algorithm because it is simple and terse, so easy to understand and use. It requires only the addition of the Cryptography package to the environment.

The program is copied from http://www.codekoala.com/posts/aes-encryption-python-using-pycrypto/, and modified. Readers are encouraged to access the original and compare it with the following modified version.

The original version was for demonstrating the algorithm, and contained many short cuts. It was also in a previous version of Python, and some of the commands would not work with Python 3. The key and cipher text was also in the Python Bytes object syntex, and would be difficult for inexperienced programmer to access and use.

The main changes are

• The codes were updated so that the program would run without error with Python 3
• Instead of a computer generated key, the key is generated from a password (a text string) chosen by the user The plain text remains the same, a text string
• The cipher text, produced during encryption, is converted to a hex string, each 2 hex character represents a byte.
• Having passwords, plain text, and cipher text all in the string format makes input/output intuitively easy to handle, and allows the transmission of these parameters to other programs and applications.

The program is as follows

from Crypto.Cipher import AES
import base64

"""
the block size for the cipher object; must be 16 per FIPS-197
block size can be set by the programmer, by commenting out
must be 16 (128 bits), 24 (192 bits) or 32 (256 bits)
"""
BLOCK_SIZE = 16    # default in original program
#BLOCK_SIZE = 24
#BLOCK_SIZE = 32

"""
The character used for padding--with a block cipher such as AES, the value
you encrypt must be a multiple of BLOCK_SIZE in length.  This character is
used to ensure that your value is always a multiple of BLOCK_SIZE
"""
#PADDING = '{'         # default from original code
PADDING = chr(0)       # to avoid error when a real character { is being coded

""" one-liner to sufficiently pad the text to be encrypted """
pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * PADDING

"""
Origonal one-liners to encrypt/encode and decrypt/decode a string 
EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s)))
DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e)).rstrip(PADDING)
"""

"""
function to encode. c an instance of the class AES
                    s the plain text
                    produces cipher text hex string
"""
EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s))).hex()
"""
function to decode. c an instance of the class AES
                    e the cipher text, a hex string
                    produces decrypted plain text string
"""
DecodeAES = lambda c, e: c.decrypt(base64.b64decode(bytes.fromhex(e))).decode().rstrip(PADDING)

"""
Alternative codes handling cipher string as base64 numbers as in original codes
and is shorter
#EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s))).decode()
#DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e.encode())).decode().rstrip(PADDING)
"""

"""
converts password (a text string) to a key (bytes object)
key is then used to instantiate class AES
"""
def PasswordToKey(pw):
    """ make key (bytes) from password and set block size """
    if len(pw) > BLOCK_SIZE : pw = pw[0 : BLOCK_SIZE] # Too long 
    i = 0
    while len(pw) < BLOCK_SIZE:                       # too short
        pw += str(pw[i])
        i += 1
    key = pw.encode()                                 # make key
    return key
        
 
def Encrypt(pw, pt):
    """ 
    pw = password
    pt = plain text
    both are chr strs
    ct is encrypted numbers in a hex string
    """
    key = PasswordToKey(pw)        # make key from password
    aes = AES.new(key)             # instantiate class AES
    ct = EncodeAES(aes, pt)        # encrypt to cipher text
    return ct
    
def Decrypt(pw, ct):
    """ 
    pw = password chr string
    ct = cipher text hex string
    pt is decrypted plain text in chrs
    """
    key = PasswordToKey(pw)        # make key from password
    aes = AES.new(key)             # instantiate class AES
    pt = DecodeAES(aes, ct)        # decrypt to plain text
    return pt
    

if __name__ == "__main__":
    """ Testing Program """
    """
    Before running program:
    1. Check BLOCK_SIZE. Must be 16, 24, or 32. Bigger more secure. 
    2. Check padding character PADDING.
    Recommend default settings unless there is good reason to do otherwise
    """
    pw = "MyPassword"         #password
    pt = "The quick brown fox jumps over the lazy gog"              #plain text
    print(pt)
    ct = Encrypt(pw, pt)  # cipher text in hex
    print(ct)
    dt = Decrypt(pw, ct)  # decrypt text (plain text)
    print(dt)
    
    print("\nExample of using actual text strings to run")
    pt = "Hello"
    print(pt)
    ct = Encrypt('MyPassword', "Hello")
    print(ct)
    dt = Decrypt('MyPassword', '754f667376704e4f484e635259616f357149537563673d3d')
    print(dt)

On running the test program, the original plain text, the cipher text is a hex string, and the decrypted palain text are printed out as follows. Please note that the cipher text is a continupus string of hex characters. I have chopped it up to fit it in the panel

The quick brown fox jumps over the lazy gog
6276486b67316d366d696657574d5774455877416d414a42303054697a62503571503545674d644f5
84b5772426563546a43712b76612f47723630774154484b
The quick brown fox jumps over the lazy gog

Example of using actual text strings to run
Hello
754f667376704e4f484e635259616f357149537563673d3d
Hello

This program is downloaded from https://github.com/DimuthuKasunWP/AES_Algorithm_Cryptography/blob/master/aes.py and modified as follows

• The testing part of the program removed
• Two additional functions Encrypt and Decrypt (both capital letters E and D), which edits input and output as text strings before submitted them to the original functions of encrypt and decrypt (little e and d)
• The password is a string of any length. The program modifies it to a key of 16 bytes
• The plain text is a character string of any length. The program takes chunks of 16 characters and encrypt them
• The cipher text is a hex string, where each 2 chrs represents a byte value

Please also note:This program contains more than the core AES. It includes a randomized padding to make the encryption more difficult to analyse, and therefore more secure. The cipher text is therefore longer than the plain text, and for the same password and plain text, a different cipher text is produced each time The program is as follows

"""
This is an exercise in secure symmetric-key encryption, implemented in pure
Python (no external libraries needed).
Original AES-128 implementation by Bo Zhu (http://about.bozhu.me) at 
https://github.com/bozhu/AES-Python . PKCS#7 padding, CBC mode, PKBDF2, HMAC,
byte array and string support added by me at https://github.com/boppreh/aes. 
Other block modes contributed by @righthandabacus.
Although this is an exercise, the `encrypt` and `decrypt` functions should
provide reasonable security to encrypted messages.
"""

s_box = (
    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
)

inv_s_box = (
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)


def sub_bytes(s):
    for i in range(4):
        for j in range(4):
            s[i][j] = s_box[s[i][j]]


def inv_sub_bytes(s):
    for i in range(4):
        for j in range(4):
            s[i][j] = inv_s_box[s[i][j]]


def shift_rows(s):
    s[0][1], s[1][1], s[2][1], s[3][1] = s[1][1], s[2][1], s[3][1], s[0][1]
    s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
    s[0][3], s[1][3], s[2][3], s[3][3] = s[3][3], s[0][3], s[1][3], s[2][3]


def inv_shift_rows(s):
    s[0][1], s[1][1], s[2][1], s[3][1] = s[3][1], s[0][1], s[1][1], s[2][1]
    s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
    s[0][3], s[1][3], s[2][3], s[3][3] = s[1][3], s[2][3], s[3][3], s[0][3]

def add_round_key(s, k):
    for i in range(4):
        for j in range(4):
            s[i][j] ^= k[i][j]


# learned from http://cs.ucsb.edu/~koc/cs178/projects/JT/aes.c
xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)


def mix_single_column(a):
    # see Sec 4.1.2 in The Design of Rijndael
    t = a[0] ^ a[1] ^ a[2] ^ a[3]
    u = a[0]
    a[0] ^= t ^ xtime(a[0] ^ a[1])
    a[1] ^= t ^ xtime(a[1] ^ a[2])
    a[2] ^= t ^ xtime(a[2] ^ a[3])
    a[3] ^= t ^ xtime(a[3] ^ u)


def mix_columns(s):
    for i in range(4):
        mix_single_column(s[i])


def inv_mix_columns(s):
    # see Sec 4.1.3 in The Design of Rijndael
    for i in range(4):
        u = xtime(xtime(s[i][0] ^ s[i][2]))
        v = xtime(xtime(s[i][1] ^ s[i][3]))
        s[i][0] ^= u
        s[i][1] ^= v
        s[i][2] ^= u
        s[i][3] ^= v

    mix_columns(s)


r_con = (
    0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
    0x80, 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A,
    0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A,
    0xD4, 0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91, 0x39,
)


def bytes2matrix(text):
    """ Converts a 16-byte array into a 4x4 matrix.  """
    return [list(text[i:i+4]) for i in range(0, len(text), 4)]

def matrix2bytes(matrix):
    """ Converts a 4x4 matrix into a 16-byte array.  """
    return bytes(sum(matrix, []))

def xor_bytes(a, b):
    """ Returns a new byte array with the elements xor'ed. """
    return bytes(i^j for i, j in zip(a, b))

def inc_bytes(a):
    """ Returns a new byte array with the value increment by 1 """
    out = list(a)
    for i in reversed(range(len(out))):
        if out[i] == 0xFF:
            out[i] = 0
        else:
            out[i] += 1
            break
    return bytes(out)

def pad(plaintext):
    """
    Pads the given plaintext with PKCS#7 padding to a multiple of 16 bytes.
    Note that if the plaintext size is a multiple of 16,
    a whole block will be added.
    """
    padding_len = 16 - (len(plaintext) % 16)
    padding = bytes([padding_len] * padding_len)
    return plaintext + padding

def unpad(plaintext):
    """
    Removes a PKCS#7 padding, returning the unpadded text and ensuring the
    padding was correct.
    """
    padding_len = plaintext[-1]
    assert padding_len > 0
    message, padding = plaintext[:-padding_len], plaintext[-padding_len:]
    assert all(p == padding_len for p in padding)
    return message

def split_blocks(message, block_size=16):
        assert len(message) % block_size == 0
        return [message[i:i+16] for i in range(0, len(message), block_size)]


class AES:
    """
    Class for AES-128 encryption with CBC mode and PKCS#7.
    This is a raw implementation of AES, without key stretching or IV
    management. Unless you need that, please use `encrypt` and `decrypt`.
    """
    rounds_by_key_size = {16: 10, 24: 12, 32: 14}
    def __init__(self, master_key):
        """
        Initializes the object with a given key.
        """
        assert len(master_key) in AES.rounds_by_key_size
        self.n_rounds = AES.rounds_by_key_size[len(master_key)]
        self._key_matrices = self._expand_key(master_key)

    def _expand_key(self, master_key):
        """
        Expands and returns a list of key matrices for the given master_key.
        """
        # Initialize round keys with raw key material.
        key_columns = bytes2matrix(master_key)
        iteration_size = len(master_key) // 4

        # Each iteration has exactly as many columns as the key material.
        columns_per_iteration = len(key_columns)
        i = 1
        while len(key_columns) < (self.n_rounds + 1) * 4:
            # Copy previous word.
            word = list(key_columns[-1])

            # Perform schedule_core once every "row".
            if len(key_columns) % iteration_size == 0:
                # Circular shift.
                word.append(word.pop(0))
                # Map to S-BOX.
                word = [s_box[b] for b in word]
                # XOR with first byte of R-CON, since the others bytes of R-CON are 0.
                word[0] ^= r_con[i]
                i += 1
            elif len(master_key) == 32 and len(key_columns) % iteration_size == 4:
                # Run word through S-box in the fourth iteration when using a
                # 256-bit key.
                word = [s_box[b] for b in word]

            # XOR with equivalent word from previous iteration.
            word = xor_bytes(word, key_columns[-iteration_size])
            key_columns.append(word)

        # Group key words in 4x4 byte matrices.
        return [key_columns[4*i : 4*(i+1)] for i in range(len(key_columns) // 4)]

    def encrypt_block(self, plaintext):
        """
        Encrypts a single block of 16 byte long plaintext.
        """
        assert len(plaintext) == 16

        plain_state = bytes2matrix(plaintext)

        add_round_key(plain_state, self._key_matrices[0])

        for i in range(1, self.n_rounds):
            sub_bytes(plain_state)
            shift_rows(plain_state)
            mix_columns(plain_state)
            add_round_key(plain_state, self._key_matrices[i])

        sub_bytes(plain_state)
        shift_rows(plain_state)
        add_round_key(plain_state, self._key_matrices[-1])

        return matrix2bytes(plain_state)

    def decrypt_block(self, ciphertext):
        """
        Decrypts a single block of 16 byte long ciphertext.
        """
        assert len(ciphertext) == 16

        cipher_state = bytes2matrix(ciphertext)

        add_round_key(cipher_state, self._key_matrices[-1])
        inv_shift_rows(cipher_state)
        inv_sub_bytes(cipher_state)

        for i in range(self.n_rounds - 1, 0, -1):
            add_round_key(cipher_state, self._key_matrices[i])
            inv_mix_columns(cipher_state)
            inv_shift_rows(cipher_state)
            inv_sub_bytes(cipher_state)

        add_round_key(cipher_state, self._key_matrices[0])

        return matrix2bytes(cipher_state)

    def encrypt_cbc(self, plaintext, iv):
        """
        Encrypts `plaintext` using CBC mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        plaintext = pad(plaintext)

        blocks = []
        previous = iv
        for plaintext_block in split_blocks(plaintext):
            # CBC mode encrypt: encrypt(plaintext_block XOR previous)
            block = self.encrypt_block(xor_bytes(plaintext_block, previous))
            blocks.append(block)
            previous = block

        return b''.join(blocks)

    def decrypt_cbc(self, ciphertext, iv):
        """
        Decrypts `plaintext` using CBC mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        blocks = []
        previous = iv
        for ciphertext_block in split_blocks(ciphertext):
            # CBC mode decrypt: previous XOR decrypt(ciphertext)
            blocks.append(xor_bytes(previous, self.decrypt_block(ciphertext_block)))
            previous = ciphertext_block

        return unpad(b''.join(blocks))

    def encrypt_pcbc(self, plaintext, iv):
        """
        Encrypts `plaintext` using PCBC mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        plaintext = pad(plaintext)

        blocks = []
        prev_ciphertext = iv
        prev_plaintext = bytes(16)
        for plaintext_block in split_blocks(plaintext):
            # PCBC mode encrypt: encrypt(plaintext_block XOR (prev_ciphertext XOR prev_plaintext))
            ciphertext_block = self.encrypt_block(xor_bytes(plaintext_block, xor_bytes(prev_ciphertext, prev_plaintext)))
            blocks.append(ciphertext_block)
            prev_ciphertext = ciphertext_block
            prev_plaintext = plaintext_block

        return b''.join(blocks)

    def decrypt_pcbc(self, ciphertext, iv):
        """
        Decrypts `plaintext` using PCBC mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        blocks = []
        prev_ciphertext = iv
        prev_plaintext = bytes(16)
        for ciphertext_block in split_blocks(ciphertext):
            # PCBC mode decrypt: (prev_plaintext XOR prev_ciphertext) XOR decrypt(ciphertext_block)
            plaintext_block = xor_bytes(xor_bytes(prev_ciphertext, prev_plaintext), self.decrypt_block(ciphertext_block))
            blocks.append(plaintext_block)
            prev_ciphertext = ciphertext_block
            prev_plaintext = plaintext_block

        return unpad(b''.join(blocks))

    def encrypt_cfb(self, plaintext, iv):
        """
        Encrypts `plaintext` using CFB mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        plaintext = pad(plaintext)

        blocks = []
        prev_ciphertext = iv
        for plaintext_block in split_blocks(plaintext):
            # CFB mode encrypt: plaintext_block XOR encrypt(prev_ciphertext)
            ciphertext_block = xor_bytes(plaintext_block, self.encrypt_block(prev_ciphertext))
            blocks.append(ciphertext_block)
            prev_ciphertext = ciphertext_block

        return b''.join(blocks)

    def decrypt_cfb(self, ciphertext, iv):
        """
        Decrypts `plaintext` using CFB mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        blocks = []
        prev_ciphertext = iv
        for ciphertext_block in split_blocks(ciphertext):
            # CFB mode decrypt: ciphertext XOR decrypt(prev_ciphertext)
            plaintext_block = xor_bytes(ciphertext_block, self.decrypt_block(prev_ciphertext))
            blocks.append(plaintext_block)
            prev_ciphertext = ciphertext

        return unpad(b''.join(blocks))

    def encrypt_ofb(self, plaintext, iv):
        """
        Encrypts `plaintext` using OFB mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        plaintext = pad(plaintext)

        blocks = []
        previous = iv
        for plaintext_block in split_blocks(plaintext):
            # OFB mode encrypt: plaintext_block XOR encrypt(previous)
            block = self.encrypt_block(previous)
            ciphertext_block = xor_bytes(plaintext_block, block)
            blocks.append(ciphertext_block)
            previous = block

        return b''.join(blocks)

    def decrypt_ofb(self, ciphertext, iv):
        """
        Decrypts `plaintext` using OFB mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        blocks = []
        previous = iv
        for ciphertext_block in split_blocks(ciphertext):
            # OFB mode decrypt: ciphertext XOR decrypt(previous)
            block = self.decrypt_block(previous)
            plaintext_block = xor_bytes(ciphertext_block, block)
            blocks.append(plaintext_block)
            previous = block

        return unpad(b''.join(blocks))

    def encrypt_ctr(self, plaintext, iv):
        """
        Encrypts `plaintext` using CTR mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        plaintext = pad(plaintext)

        blocks = []
        nonce = iv
        for plaintext_block in split_blocks(plaintext):
            # CTR mode encrypt: plaintext_block XOR encrypt(nonce)
            block = xor_bytes(plaintext_block, self.encrypt_block(nonce))
            blocks.append(block)
            nonce = inc_bytes(nonce)

        return b''.join(blocks)

    def decrypt_ctr(self, ciphertext, iv):
        """
        Decrypts `plaintext` using CTR mode and PKCS#7 padding, with the given
        initialization vector (iv).
        """
        assert len(iv) == 16

        blocks = []
        nonce = iv
        for ciphertext_block in split_blocks(ciphertext):
            # CTR mode decrypt: ciphertext XOR decrypt(nonce)
            block = xor_bytes(ciphertext_block, self.decrypt_block(nonce))
            blocks.append(block)
            nonce = inc_bytes(nonce)

        return unpad(b''.join(blocks))


import os
from hashlib import pbkdf2_hmac
from hmac import new as new_hmac, compare_digest

AES_KEY_SIZE = 16
HMAC_KEY_SIZE = 16
IV_SIZE = 16

SALT_SIZE = 16
HMAC_SIZE = 32

def get_key_iv(password, salt, workload=100000):
    """
    Stretches the password and extracts an AES key, an HMAC key and an AES
    initialization vector.
    """
    stretched = pbkdf2_hmac('sha256', password, salt, workload, AES_KEY_SIZE + IV_SIZE + HMAC_KEY_SIZE)
    aes_key, rest = stretched[:AES_KEY_SIZE], stretched[AES_KEY_SIZE:]
    hmac_key, rest = stretched[:HMAC_KEY_SIZE], stretched[HMAC_KEY_SIZE:]
    iv = stretched[:IV_SIZE]
    return aes_key, hmac_key, iv


def encrypt(key, plaintext, workload=100000):
    """
    Encrypts `plaintext` with `key` using AES-128, an HMAC to verify integrity,
    and PBKDF2 to stretch the given key.
    The exact algorithm is specified in the module docstring.
    """
    if isinstance(key, str):
        key = key.encode('utf-8')
    if isinstance(plaintext, str):
        plaintext = plaintext.encode('utf-8')

    salt = os.urandom(SALT_SIZE)
    key, hmac_key, iv = get_key_iv(key, salt, workload)
    ciphertext = AES(key).encrypt_cbc(plaintext, iv)
    hmac = new_hmac(hmac_key, salt + ciphertext, 'sha256').digest()
    assert len(hmac) == HMAC_SIZE

    return hmac + salt + ciphertext


def decrypt(key, ciphertext, workload=100000):
    """
    Decrypts `plaintext` with `key` using AES-128, an HMAC to verify integrity,
    and PBKDF2 to stretch the given key.
    The exact algorithm is specified in the module docstring.
    """

    assert len(ciphertext) % 16 == 0, "Ciphertext must be made of full 16-byte blocks."

    assert len(ciphertext) >= 32, """
    Ciphertext must be at least 32 bytes long (16 byte salt + 16 byte block). To
    encrypt or decrypt single blocks use `AES(key).decrypt_block(ciphertext)`.
    """

    if isinstance(key, str):
        key = key.encode('utf-8')

    hmac, ciphertext = ciphertext[:HMAC_SIZE], ciphertext[HMAC_SIZE:]
    salt, ciphertext = ciphertext[:SALT_SIZE], ciphertext[SALT_SIZE:]
    key, hmac_key, iv = get_key_iv(key, salt, workload)

    expected_hmac = new_hmac(hmac_key, salt + ciphertext, 'sha256').digest()
    assert compare_digest(hmac, expected_hmac), 'Ciphertext corrupted or tampered.'

    return AES(key).decrypt_cbc(ciphertext, iv)

"""
                    END IMPORTED ORIGINAL PROGRAM

Encrypt and Decrypt are Added functions, mostly to manipulate 
        the input and output into text strings
"""
def Encrypt(password, plainText):
    """
    password and plainText are both character texts. They can be any length,
             returns cipherText, a hex string
    """
    cipherBytes = encrypt(password, plainText)  
    cipherList = bytearray(cipherBytes)  # bytes object to byte list
    cipherText = ""                      # byte list to hex string
    for v in cipherList: 
        hx = hex(v)[2:]
        if len(hx)<2: hx = "0" + hx
        cipherText += hx
    return cipherText                    #hex string

def Decrypt(password, cipherText):
    """
    password is character texts. It can be any lengthut must be the same 
             as the encrypting password
    cipherText is a hex string as created by Encrypt
             result bytes object is then converted to plain text
    """
    cipherByteList = []            # hex string to byte list
    i = 0
    while i<len(cipherText):      
        cipherByteList.append(int(cipherText[i:i+2],16))
        i+=2
    cipherBytes = bytearray(cipherByteList)     # byte list to byte object
    decryptedBytes = decrypt(password,cipherBytes) 
    return decryptedBytes.decode()              # text string

if __name__ == '__main__': 
    """
    Testing
    """

    password = "MyPassword"
    plainText = "The quick brown fox jumps over the lazy dog"
    cipherText = Encrypt(password, plainText)
    print(cipherText)
    decryptedText = Decrypt(password, cipherText)
    print(decryptedText)

The results are as follows. Note: the cipher text hex string is a continuous line, I have chopped it up to fit into the panel

67448b5c8dbb19e9c934bdf6455f19b36888d45575db80a1577c56bc3c157fbf70b913a631bd5
e3092d1a08f39fbbbf983e88256eaadf2ab7c2bb7c4637a38ae06dd7ed078f0ac916c94960b87
c3bcb6b481041121303ee62f6e4f7d930be0fb
The quick brown fox jumps over the lazy dog

There are numerous resources available on the www regarding RSA, examples of which are wikipedia and this tutorial. Only a very brief introduction will therefore be offered in this page, to be the basis of understanding and discussions of the programs.

RSA is the asymmetical key encryption that is in common use (2021). The mathematical principles are as follows

• There are 3 keys involved
  • The common key, (termed variously modulus, MOD, P*Q, pq, n, or M). This is a product of two prime numbers P and Q (M = P*Q)
  • The public key, (termed variously as the encrypting key, E).
  • The private key, (termed variously as the decrypting key, D).
  • E and D are derived from M
• For encryption and decryption, if the plain number is Pn, the encrypted number is En, and the decrypted number is Dn, then
  • En = Pn^E % M
  • Dn = En^D % M (Pn and Dn are the same number)
• The size of the keys is measured in bits, where M is expressed to the nearest 2^bit
  • The larger the size, the more secure is the encryption, but the longer the time required for calculation
  • 16 bits key is considered sufficient for personal use, 64 for commercial, and 512 for military. However, with increasing power of computers, much larger size keys are now commonly in use.

This page offers the RSA algorithm in 3 formats

• A very short Python program that uses the imported package Cryptography. This was originally copied from a tutorial page on the www, but modified to reduce the running time, and simplify transfer of keys.
  • The advantages of using this program is that it is short and fast, with automatic selection of prime numbers and keys, and able to produce and use keys of any size.
  • The disadvantages are that the codes are opacque, transferring of keys and results to other applications difficult for the amateur programmer, and if the keys are too large, takes a very long time to run
• A slightly longer Python program, requiring no additional library. This was originally copied from Github, but modified to reduce running time and simplified transferring or keys and results
  • The advantages are that the codes are transparent, the running time short, and that keys and results are easily understood and transferable.
  • The disadvantages are that it requires users to insert the prime numbers P and Q, and an option to insert the public key E
• An interactive web page program based on Javascript. The program is a direct translation of the second Python program into Javascript.
  • The advantages are that the program is immediately available on the web page, without the need to install and activate Python. The keys and results are also intuitively easy to understand and use.
  • The disadvantage is the limitation of Javascript, both in the largest number it can handle, and the slowness of calculation. The key size is so limited (<16 bits) that it is hardly adequate even for personal use.
  The Javascript program is therefore intended as a demonstration to beginners on how RSA works, and not intended for serious crytography. Additional discussions on RSA and how to use the program are provided at the bottom of the Javascript panel

Please Note: The 3 programs are all based on the basic RSA algorithm, but the size of keys used and the formats for input and output are very different. The keys produced cannot be interchangeably used in the other programs and the cipher text produced by one can therefore not be decrypted by the others

Note: Detailed discussions on doing RSA in Javascript in Section 5, bottom of this panel

Section 1. Create Keys

P Q E Show Details		- P and Q are 2 prime numbers to be inserted by users - Prime numbers can be found in List by Wikipedia - Public key E must be compatible with P and Q (see section 5). - Show Details, if checked, requires considerably longer run time - Example inserts default examples of P, Q, & E

Section 2. Keys To Be Used for Encryption and Decryption in Sections 3 and 4

Common (P*Q, n, pq, MOD) Public (encryption key, E) Private (decryption key D)	- Common key required for both encryption and decryption - Public key required only for encryption - Private key required only for decryption - Values are inserted by user, or when section 1 is run

Section 3. Encrypt or Decrypt a Number Using Keys in Section 2

Number To Process	- The appropriate keys in Section 2 must be available - Number must be >0 and < the common key (P*Q) - Any error returns value of -1

Section 4. Encrypt or Decrypt Text string Using Keys in Section 2

4.a. Encrypt character text string to space delimited numerical string

	- Common (P*Q) and public (E) keys in Section 2 must be available - Text string of characters in the text area - Encrypted to space delimited numerical string - Errors represented by -1 - Results posted to textarea in section 4.b. - Example inserts a default example string

4.b. Decrypt space delimited numerical string to character text string

	- Common (P*Q) and private (D) keys in Section 2 must be available - Space delimited string of numbers in the text area - Decrypted to a character text string - Errors causes unpredictable characters - Results posted to textarea in section 4.a. - Example inserts a default example string

Section 5. Discussions

Key size (Section 1)

Although RSA is conceptually simple and elegant, requiring only a few lines of code to perform the task, it presents major difficulties in implementation using Javascript. The main difficulty is the size of the numbers used in calculation, and from that the time it takes to do the calculations.

The encryption and decryption both use the formula (data^key) % modulus, the larger the key, the more secure but also takes longer to calculate. Ordinary Javascript has a maximum value of 2⁵² so the level of security obtained is hardly worth the effort. With the introduction of the data type BigInt larger numbers can be processed. However, the program crashes when calculating nⁿ, if n > 65534. At that level, even if the calculation is possible, it takes a very long time to complete.

As the modulus (P*Q, n, MOD) is the largest number in the equation, and represents key size, a limit of P*Q<65534 is imposed on the Javascript program in this panel. This represents a key size of just under 16 bits. This means that the algorithm in this panel is not secure enough for commercial use, and is thus for demonstrating how RSA works only.

Creating the keys (Section 1)

• Two prime numbers (P and Q) are required to create the keys. The program on this panel requires the user to enter these numbers. Prime numbers are widely available on the www, and a link to the wikipedia list is included. Users are reminded that, for the Javascript program, the product of the two prime numbers (P*Q) must not exceed 65534, or the program will crash.
• The public key, used for encryption (E) is optional. The key must be >1 and <P*Q and is a co-prime with P and Q. If E=0, E>P*Q, or the E field is left blank, the program overrides the choice, and selects a random but appropriate E value. This would be the option if the user is unable to identify a correct value for the public key
  Please note that, if the same P, Q, and E is provided, each run will produce the same encrypting and decrypting keys. If E is randomly chosen by the program, then the encrypting and decrypting keys can be different from run to run,
• If the Example button is clicked, the program assigns the default values of 97 and 83 as P and Q, and 4067 as E before calculating the keys
• The 3 keys, the common key (also known as modulus, P*Q, pq, n, MOD), the public key (also known as encrypting key, E), and private key (also known as the decryting key, D) are produced, and deposited ihto the text boxes in Section 2, so they can be used for subsequent calculation
• If the checkbox Show Details is checked, the values of all intermediate parameters are shown, then the program checks encryption and decryption through all the byte values (0 to 255) to maks sure all bytes can be encrypted and decrypted. This may take considerable time, up to 10 minutes when the key size is closed to the limit.

The keys (Section 2)

The keys are in the text boxes of Section 2. The values are inserted when section 1 (creating keys) is run, or the user can enter previously created keys by hand. The public key (E) is required for encryption, and private key (D) for decryption, and the common key (P*Q) is required for both.

Encrypting or decrypting a number (Section 3) The appropriate keys must be present in the text boxes of section 2, and the number must be > 0 and < the value of the common key. If there is an error the value of -1 is returned

Encrypting a character string (Section 4.a.)

• The input is a text string of characters
• Encryption will use the current keys in section 2. The common and (P*Q) and encrypting key (E) must be present
• The result is a text string of space delimited numbers, each represents an encrypted character. This is placed into the text area of section 4.b.
• Clicking the Example button will cause the default text "Hello" to be inserted into the input text area in 4.a., and the string of its encrypted numbers into 4.b.

Decrypting a string of numbers separated by single spaces (Section 4.b.)

• The input is a text string of numbers. The numbers are previously encrypted from characters
• The numbers must be separated by a single space. Including multiple spaces or tabs will lead to errors
• Decryption will use the current keys in section 2. The common and (P*Q) and decrypting key (D) must be present. If the keys are different to the set that encrypted the characters in the first place, gibberish will result.
• The result (if correct) is a text string of characters decrypted from the numbers. This is placed into the text area of section 4.a.

This program was originally copied from https://www.tutorialspoint.com/cryptography_with_python/cryptography_with_python_symmetric_and_asymmetric_cryptography.htm. This is the simplest RSA program that contains all the following features

• It is short and easy to use
• It uses the Cryptography package, and is very fast
• It automatically generates key of large size that is hard to hack
• It accepts plain text and produces decrypted text as plain charcter texts
• The keys and cipher text however are in the base 64 bytes format. This is simple for the experienced Python programmers, but can be confusing to the inexperienced Python users

In order to make it easier for the inexperienced Python programmer, I have added additional functions so that

• The public and provate keys are separated, and are text strings of b64 characters. They can be handled as ordinary strings
• The cipher text is also converted to a text string of b64 characters. It can also be handled as an ordinary string
• Encryption and Decryption functions are created that handle input and output parameters in the string format

Readers are encouraged to download the full original program and compare it with the modified version below

from Crypto import Random
from Crypto.PublicKey import RSA
import base64

def generate_keys():
   # key length must be a multiple of 256 and >= 1024
   modulus_length = 256*4
   privatekey = RSA.generate(modulus_length, Random.new().read)
   publickey = privatekey.publickey()
   return privatekey, publickey

def encrypt_message(a_message , publickey):
   encrypted_msg = publickey.encrypt(a_message, 32)[0]
   encoded_encrypted_msg = base64.b64encode(encrypted_msg)
   return encoded_encrypted_msg

def decrypt_message(encoded_encrypted_msg, privatekey):
   decoded_encrypted_msg = base64.b64decode(encoded_encrypted_msg)
   decoded_decrypted_msg = privatekey.decrypt(decoded_encrypted_msg)
   return decoded_decrypted_msg



"""
           END OF ORIGINAL PROGRAM
The following are additions to handle keys and messages as texts
"""
def GenerateKeys():
    privatekey , publickey = generate_keys()   #calls original function
    #modify public key
    publickeyList = publickey.exportKey().decode().split() # turn to list
    reducedList =[publickeyList[i] for i in range(3,len(publickeyList)-3)] #chop out descriptions
    publicKey = '\n'.join(reducedList)    # reconstitute the core part
    #modifies private key
    privatekeyList = privatekey.exportKey().decode().split() # turn to list
    reducedList =[privatekeyList[i] for i in range(4,len(privatekeyList)-4)] #chop out descriptions
    privateKey = '\n'.join(reducedList)    # reconstitute the core part
    return privateKey, publicKey   # returns both keys as base 64 text strings
     
def Encrypt(publicKey, plainText): #public key and plain text are b64 and chr strings
    pub = RSA.importKey(base64.b64decode(publicKey.encode())) # converts to b64 byte object
    return encrypt_message(plainText.encode() , pub).decode() # cipher text as b64 string
 
def Decrypt(privateKey, cipherText): #private key and cipher text both b64 string
    pri = RSA.importKey(base64.b64decode(privateKey.encode())) # converts to b64 byte object
    return decrypt_message(cipherText.encode() , pri).decode() # decypted chr string

if __name__ == "__main__":
    # create keys
    privateKey, publicKey = GenerateKeys() 
    print('privateKey')
    print(privateKey)
    print('publicKey')
    print(publicKey)
    # plain text
    plainText = "The quick brown fox jumps over the lazy dog"
    print('Original Plain Text Message')
    print(plainText)
    # Encrypt 
    cipherText = Encrypt(publicKey, plainText)
    print('cipher textext')
    print(cipherText)
    # Decipher
    decryptedText = Decrypt(privateKey, cipherText)
    print('decrypted text')
    print(decryptedText)
    
    # Direct I/O
    print('\nTesting Direct Input')
    cipherText = Encrypt('MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCZN6rVXbmiROt\
FYM/NsGluUdbkrXh+NtOVER4an6Tf+u1Ac6zD8/QN0vUDxNQ4YwINhxUkIFzUPu774cIi7muaUhZY\
IZP847xgFW78bhEKrYb0o4Noy0q1OyGftZoT1WFiHiTRiPFjqwg0HAyjavnqTeq7eObmvkz21LcX8/\
38UQIDAQAB', 'Hello There')
    print(cipherText)
    decryptedText = Decrypt('MIICXQIBAAKBgQCZN6rVXbmiROtFYM/NsGluUdbkrXh+NtOV\
ER4an6Tf+u1Ac6zD8/QN0vUDxNQ4YwINhxUkIFzUPu774cIi7muaUhZYIZP847xgFW78bhEKrYb0o4\
Noy0q1OyGftZoT1WFiHiTRiPFjqwg0HAyjavnqTeq7eObmvkz21LcX8/38UQIDAQABAoGAChaDNfcs\
0MVO5EuCgx15Y50Z1Aaj51N+zNLKs6ANP/4KfvLeziwSxpI8NZpRCsFiEjfxqWZEFmlqXMU5fglKpk\
1oayv4dqxlaur+2wht76OAN3QWe0jAE97MZw9jqd8Vnf0pqduXank/oC27p10RGCf3yYrvXxYwL3+7\
4bcm9/0CQQDAvzh72jSrACrOMHyjB6tluMwLxXgOyESuyLfTevOlHzz6hwaMz/21n4yReX9+i3+y5R\
pVNM2QbVHiH4sZIQvrAkEAy3+NBmR9W6yG45YvJkjoihVLozIzd24sCCYCxWxa8Ce9YzyNn+srLz9l\
bcBXrJE6i9ZfxssS+dOtu6G6W4E1swJBAIyU6+WpqXBvlsj8pGtkVKbEuk57oK1ndHDnBOzCaKKuvh\
McGLLroOivjh8stsjdhi4824/6C1Sj520+BH43lDECQQC7TIrgd11qI0GD95cuBa0CatdTPcFhC2Y7\
mcCzNSf+IpWN4Q35Qtpcgl04xu/rRUA9tPIyZnbwuoQNTq3XyvVBAkA8sWPkBOaAr50YbDLorcZiq4\
o2XOXM8bFm4HUV1Fidz22t/IQuUMFOFo+V/YRzPgULDrjQqWOd9Hiajq1UKe3y', 'Bb4WbQ865UIR\
Q0NN1lCUOwOQnkHsuHHeCG2SCItwYTKEFiNZiT5RNK0rifpAOnYKDI/KGutb39xcsusD/rzliDVTa9\
2a1P1c26hdFCiiPXkXsSNxLkuJb7a0ycj+gGZRcoOfasKRrJoy9bZ7Uk69On2+A/R0l+c3xqlTAxFP\
n6w=')
    print(decryptedText)    

The output is as follows. Please note keys and cipher text should be single continuous lines. I have chopped them up to fit them to the panel

privateKey
MIICWgIBAAKBgQC60O46dOSmIGWIN4yGqB8oC+tj7jbVYHmWnUB7wi5DwUFFnPzO
3tCP7vl4TBgTHqchGzbngvcmvQOLx9u1hzEerBdog1F/NX1ZQtxxR9C981m4nwp1
1PrejUVY1/FB8Xi/CHLTfsyCcEhHaG5qyarANqFxYm2LARaWnjpNJnslVwIDAQAB
An90B0/u/qsEgxqMf/PHrqOrO7v3VPy5ijH6WbCzLOePLXhcxCRAWCMxQjuve5N4
TJGA/mYbZDwc00hgiMDs/gqC790E9+1Us/SByqWwIcbOL90mtq25HrRXGnraFEsh
FS8cPVNyVPw/FTfYsQPRfLNgm8jj9VDV4IvBdJnRKa9BAkEAvTAhPbUjlS6yat6O
k2LgHbtJBVdKzkzRytpG9BzRu594CHwDhFQqJyafWDEsv8gN9yEgD5Xv2ml0Fygo
yPLXIQJBAPzKXhVlIkJ2kLXun3AO+UOiuLvJAX0i1+/KIrNLP01+zZAq1vgqIW8G
ZjJGFPqPMPH1DIEztjYps25Yi8o1hXcCQD3pbUdrauycLokoshHrjppMOvZDfdiL
bTBsREII2F4FLtvf8aqxfGX5jrXmydUtG9ze+0X+dFLOpc4aN1ajmeECQQCflLDo
GLwT8P1RnJ4SA6HfzK2J/k5uTLy8p4JYZTxFE7N5O1IRv6bzi7qgKhW8RwDC/csz
FQ4GCzU2h7dXo4npAkAIkhgS0G9wRXwXn6uhpYzb4DnP0kW12usc6U3sf6qMYbh6
5+6Bl3+PwL+SPkAj+huUchMKUwbArvBQAtv048l8
publicKey
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC60O46dOSmIGWIN4yGqB8oC+tj
7jbVYHmWnUB7wi5DwUFFnPzO3tCP7vl4TBgTHqchGzbngvcmvQOLx9u1hzEerBdo
g1F/NX1ZQtxxR9C981m4nwp11PrejUVY1/FB8Xi/CHLTfsyCcEhHaG5qyarANqFx
Ym2LARaWnjpNJnslVwIDAQAB
Original Plain Text Message
The quick brown fox jumps over the lazy dog
cipher textext
ar5mHqmYWARjaYabK4dNbAAuwUVhWChLvkJhjQALLv8Vk853Q6/Summy1//CACLQR
zX276wkVxFx9mCwtPTycyuKYSuyaS6OgIqimPEjYoRVg7ean/c7bPaCoHC+xC4p8C
qAIoBQGHSpIDJoZ2xyP3KcWNQFsRG0xicuBQ2Ps+0=
decrypted text
The quick brown fox jumps over the lazy dog

Testing Direct Input
Bb4WbQ865UIRQ0NN1lCUOwOQnkHsuHHeCG2SCItwYTKEFiNZiT5RNK0rifpAOnYKDI
/KGutb39xcsusD/rzliDVTa92a1P1c26hdFCiiPXkXsSNxLkuJb7a0ycj+gGZRcoOf
asKRrJoy9bZ7Uk69On2+A/R0l+c3xqlTAxFPn6w=
Hello There

This program is adapted from the source code in https://github.com/liudonghua123/RSA-Python/blob/master/RSA_Python.py

The original program search through all possible prime numbers and testing them, so it takes a long time to run. I have made the following modifications, to truncate run time, and also to reduce the complexity so that less experienced programmer can cope with it.

• P and Q are prime numbers defined by users and not searched. Key size will be defined by the size of these prime numbers
• There is no error checking for prime numbers. If the user input a non-prime number, the results will be unpredictable
• Two options for the public (encryption) key E.
  • If public key E is not specified, the program will search for one that works. It takes a little longer, and a different sets of keys will be produced with each run
  • If public key E is specified, the program will use that. It takes less time to run, and the same key pair will be produced each time. However, the correct key must be used (it must be a co-prime to P and Q). If the wrong number is used, the results will be unpredictable. An easy way out is to use another prime number, or use 0x1001 (4097), as this always works, and public key need not be secret
  • The input plain text is just that, a string of characters
  • The cipher text, both produced during encryption and input doe decipher, is a text string containing space delimited numbers, each represents an encrypted byte of the character
  The codes are as follows

  import random
  #required for randrange
  
  def gcd(a, b):
      if b == 0:
          return a
      else:
          return gcd(b, a % b)
  
  
  def mod_inverse(a, m):
      for x in range(1, m):
          if (a * x) % m == 1:
              return x
      return -1
  
  
  def generate_keypair(p, q, e=None):
      """
      Generates key pair from two prime numbers p and q
      e is optional
        if e is provided the same key pair will be generated each time
        if e is not provided e is random so will be different each run
      """
      print("p=%i, q=%i" % (p,q))
      n = p * q
      print("n, MOD, pq, p*q = %i" % n)
      phi = (p - 1) * (q - 1)
      print("phi, T, (p-1)(q-1) = %i" % phi)
  
      if e==None:
          while True:
              #as long as gcd(1,phi(n)) is not 1, keep generating e
              e = random.randrange(1, phi)
              g = gcd(e, phi)
              #generate private key
              d = mod_inverse(e, phi)
              if g == 1 and e != d:
                  break
          return ((e, n), (d, n))
      d = mod_inverse(e, phi) 
      return ((e, n), (d, n))
  
  
  def Interpret(theKey, MOD, intValue):
      return pow(intValue, theKey, MOD)
  
  
  def Encrypt(publicKey, MOD, plainText):
      """ encrypt plain text to cipher text """
      byteList = [ord(x) for x in plainText] # plain Text to byteAr
      eList =[str(Interpret(publicKey, MOD, x)) for x in byteList] # encrypted list
      cipherText = ' '.join(eList) #concatenate list as string with space separated numbers   
      return cipherText
  
  
  def Decipher(privateKey, MOD, cipherText):
      nList = cipherText.split()    #list of numbers
      dList = [chr(Interpret(privateKey, MOD, int(n))) for n in nList] #list of chrs
      decipheredText = ''.join(dList) #concatenate list to string
      return decipheredText
  
  #-------------------------------------------------------------
  """ Testing Program """
  if __name__ == "__main__":
      """
      Prime numbers can be found in
        https://en.wikipedia.org/wiki/List_of_prime_numbers
        https://www.mathsisfun.com/numbers/prime-numbers-to-10k.html
      """
      print("Test 1: Create key, encrypt a string and decipher back")
      p = 5953
      q = 83
      #public, private = generate_keypair(p, q)  # generate keys
      public, private = generate_keypair(p, q, 0x1001)  # generate keys
      print("Public Key: ", public)
      print("Private Key: ", private)
      msg = "The quick brown fox jumps over the lazy dog"
      #print([ord(c) for c in msg])
      #encrypted_msg = encrypt(msg, public)
      encrypted_msg = Encrypt(public[0], public[1], msg)
      print("Encrypted msg: ")
      print(encrypted_msg)
      #print(''.join(map(lambda x: str(x), encrypted_msg)))
      print("Decrypted msg: ")
      print(Decipher(private[0], private[1], encrypted_msg))
      
      print("\nTest 2: Encrypt and decrypt an integer")
      pN = 1234  # plain number
      eN = Interpret_Value(public[0], public[1], pN)  # encrypt
      dN = Interpret_Value(private[0], private[1], eN)  # encrypt
      print("plain=%i encrypted=%i deciphered=%i" % (pN,eN,dN))
      
      print("\nTest 3: Encrypt and decrypt alist of numbers")
      pL = [123, 456, 789]  # plain number list
      eL = Interpret_List(public[0], public[1], pL)  # encrypt
      dL = Interpret_List(private[0], private[1], eL)  # encrypt
      print("plain list")
      print(pL)
      print("encrypted List")
      print(eL)
      print("deciphered List")
      print(dL)
      
      print("\nTest 4: Enryption and decryption using actual values")
      cipherText = Encrypt(4097, 494099,"Hello There");
      print(cipherText)
      plainText = Decipher(20609, 494099, "381191 87350 428035 428035 429967 \
  489158 14194 315630 87350 203336 87350")
      print(plainText)   
  

  The results produced will be as follows.
  Please note: cipher text (Encrypted_msg)is a continuous string of numbers. I have chopped it up to fit in the panel

  Test 1: Create key, encrypt a string and decipher back
  p=5953, q=83
  n, MOD, pq, p*q = 494099
  phi, T, (p-1)(q-1) = 488064
  Public Key:  (4097, 494099)
  Private Key:  (20609, 494099)
  Encrypted msg: 
  14194 315630 87350 489158 445139 200469 258839 186647 423955
   489158 464465 203336 429967 79373 194144 489158 173434 429967
   354724 489158 278111 200469 346554 458460 349884 489158 429967
   478382 87350 203336 489158 487749 315630 87350 489158 428035
   31341 283927 464671 489158 212091 429967 66662
  Decrypted msg: 
  The quick brown fox jumps over the lazy dog
  
  Test 2: Encrypt and decrypt an integer
  plain=1234 encrypted=208053 deciphered=1234
  
  Test 3: Encrypt and decrypt alist of numbers
  plain list
  [123, 456, 789]
  encrypted List
  [282710, 376148, 304784]
  deciphered List
  [123, 456, 789]
  
  Test 4: Enryption and decryption using actual values
  381191 87350 428035 428035 429967 489158 14194 315630 87350 203336 87350
  Hello There