Implementation of Vernam Cipher or One Time Pad Algorithm

One Time Pad algorithm is the improvement of the Vernam Cipher, proposed by An Army Signal Corp officer, Joseph Mauborgne. It is the only available algorithm that is unbreakable(completely secure). It is a method of encrypting alphabetic plain text. It is one of the Substitution techniques which converts plain text into ciphertext. In this mechanism, we assign a number to each character of the Plain-Text.

The two requirements for the One-Time pad are

• The key should be randomly generated as long as the size of the message.
• The key is to be used to encrypt and decrypt a single message, and then it is discarded.

So encrypting every new message requires a new key of the same length as the new message in one-time pad.

The ciphertext generated by the One-Time pad is random, so it does not have any statistical relation with the plain text.

The assignment is as follows:

A	B	C	D	E	F	G	H	I	J
0	1	2	3	4	5	6	7	8	9
K	L	M	N	O	P	Q	R	S	T
10	11	12	13	14	15	16	17	18	19
U	V	W	X	Y	Z
20	21	22	23	24	25

The relation between the key and plain text: In this algorithm, the length of the key should be equal to that of plain text.

Examples:

Input: Message = HELLO, Key = MONEY Output: Cipher – TSYPM, Message – HELLO Explanation:     Part 1: Plain text to Ciphertext         Plain text — H E L L O ? 7 4 11 11 14         Key — M O N E Y ? 12 14 13 4 24         Plain text + key ? 19 18 24 15 38 ? 19 18 24 15 12 (= 38 – 26)         Cipher Text ? T S Y P M     Part 2: Ciphertext to Message         Cipher Text — T S Y P M ? 19 18 24 15 12         Key — M O N E Y? 12 14 13 4 24         Cipher text – key ? 7 4 11 11 -12 ? 7 4 11 11 14         Message ? H E L L O Input: Message = SAVE, Key = LIFE Output: Cipher – DIAI Message – SAVE

Security of One-Time Pad

• If any way cryptanalyst finds these two keys using which two plaintext are produced but if the key was produced randomly, then the cryptanalyst cannot find which key is more likely than the other. In fact, for any plaintext as the size of ciphertext, a key exists that produces that plaintext.
• So if a cryptanalyst tries the brute force attack(try using all possible keys), he would end up with many legitimate plaintexts, with no way of knowing which plaintext is legitimate. Therefore, the code is unbreakable.
• The security of the one-time pad entirely depends on the randomness of the key. If the characters of the key are truly random, then the characters of the ciphertext will be truly random. Thus, there are no patterns or regularities that a cryptanalyst can use to attack the ciphertext.

Advantages

• One-Time Pad is the only algorithm that is truly unbreakable and can be used for low-bandwidth channels requiring very high security(ex. for military uses).

Disadvantages

• There is the practical problem of making large quantities of random keys. Any heavily used system might require millions of random characters on a regular basis.
• For every message to be sent, a key of equal length is needed by both sender and receiver. Thus, a mammoth key distribution problem exists.

Below is the implementation of the Vernam Cipher:

C++

// C++ program Implementing One Time Pad Algorithm

#include <bits/stdc++.h>
#include <iostream>

using namespace std;
// Method 1
// Returning encrypted text
string stringEncryption(string text, string key)
{

    // Initializing cipherText
    string cipherText = "";

    // Initialize cipher array of key length
    // which stores the sum of corresponding no.'s
    // of plainText and key.
    int cipher[key.length()];

    for (int i = 0; i < key.length(); i++) {
        cipher[i] = text.at(i) - 'A' + key.at(i) - 'A';
    }

    // If the sum is greater than 25
    // subtract 26 from it
    // and store that resulting value
    for (int i = 0; i < key.length(); i++) {
        if (cipher[i] > 25) {
            cipher[i] = cipher[i] - 26;
        }
    }

    // Converting the no.'s into integers

    // Convert these integers to corresponding
    // characters and add them up to cipherText
    for (int i = 0; i < key.length(); i++) {
        int x = cipher[i] + 'A';
        cipherText += (char)x;
    }

    // Returning the cipherText
    return cipherText;
}

// Method 2
// Returning plain text
static string stringDecryption(string s, string key)
{
    // Initializing plain text
    string plainText = "";

    // Initializing integer array of key length
    // which stores difference
    // of corresponding no.'s of
    // each character of cipherText and key
    int plain[key.length()];

    // Running for loop for each character
    // subtracting and storing in the array
    for (int i = 0; i < key.length(); i++) {
        plain[i] = s.at(i) - 'A' - (key.at(i) - 'A');
    }

    // If the difference is less than 0
    // add 26 and store it in the array.
    for (int i = 0; i < key.length(); i++) {
        if (plain[i] < 0) {
            plain[i] = plain[i] + 26;
        }
    }

    // Converting int to corresponding char
    // add them up to plainText
    for (int i = 0; i < key.length(); i++) {
        int x = plain[i] + 'A';
        plainText += (char)x;
    }

    // Returning plainText
    return plainText;
}

// Method 3
// Main driver method
int main()
{
    // Declaring plain text
    string plainText = "Hello";

    // Declaring key
    string key = "MONEY";

    // Converting plain text to toUpperCase
    // function call to stringEncryption
    // with plainText and key as parameters
    for (int i = 0; i < plainText.length(); i++) {
        // convert plaintext to uppercase
        plainText[i] = toupper(plainText[i]);
    }
    for (int i = 0; i < key.length(); i++) {
        // convert key to uppercase
        key[i] = toupper(key[i]);
    }
    string encryptedText = stringEncryption(plainText, key);

    // Printing cipher Text
    cout << "Cipher Text - " << encryptedText << endl;

    // Calling above method to stringDecryption
    // with encryptedText and key as parameters

    cout << "Message - "
         << stringDecryption(encryptedText, key);

    return 0;
}

// This code was contributed by Pranay Arora

Java

// Java program Implementing One Time Pad Algorithm

// Importing required classes
import java.io.*;

// Main class
public class GFG {

    // Method 1
    // Returning encrypted text
    public static String stringEncryption(String text,
                                          String key)
    {

        // Initializing cipherText
        String cipherText = "";

        // Initialize cipher array of key length
        // which stores the sum of corresponding no.'s
        // of plainText and key.
        int cipher[] = new int[key.length()];

        for (int i = 0; i < key.length(); i++) {
            cipher[i] = text.charAt(i) - 'A'
                        + key.charAt(i)
                        - 'A';
        }

        // If the sum is greater than 25
        // subtract 26 from it
        // and store that resulting value
        for (int i = 0; i < key.length(); i++) {
            if (cipher[i] > 25) {
                cipher[i] = cipher[i] - 26;
            }
        }

        // Converting the no.'s into integers

        // Convert these integers to corresponding
        // characters and add them up to cipherText
        for (int i = 0; i < key.length(); i++) {
            int x = cipher[i] + 'A';
            cipherText += (char)x;
        }

        // Returning the cipherText
        return cipherText;
    }

    // Method 2
    // Returning plain text
    public static String stringDecryption(String s,
                                          String key)
    {
        // Initializing plain text
        String plainText = "";

        // Initializing integer array of key length
        // which stores difference
        // of corresponding no.'s of
        // each character of cipherText and key
        int plain[] = new int[key.length()];

        // Running for loop for each character
        // subtracting and storing in the array
        for (int i = 0; i < key.length(); i++) {
            plain[i]
                = s.charAt(i) - 'A'
                  - (key.charAt(i) - 'A');
        }

        // If the difference is less than 0
        // add 26 and store it in the array.
        for (int i = 0; i < key.length(); i++) {
            if (plain[i] < 0) {
                plain[i] = plain[i] + 26;
            }
        }

        // Converting int to corresponding char
        // add them up to plainText
        for (int i = 0; i < key.length(); i++) {
            int x = plain[i] + 'A';
            plainText += (char)x;
        }

        // Returning plainText
        return plainText;
    }

    // Method 3
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring plain text
        String plainText = "Hello";

        // Declaring key
        String key = "MONEY";

        // Converting plain text to toUpperCase
        // function call to stringEncryption
        // with plainText and key as parameters
        String encryptedText = stringEncryption(
            plainText.toUpperCase(), key.toUpperCase());

        // Printing cipher Text
        System.out.println("Cipher Text - "
                           + encryptedText);

        // Calling above method to stringDecryption
        // with encryptedText and key as parameters
        System.out.println(
            "Message - "
            + stringDecryption(encryptedText,
                               key.toUpperCase()));
    }
}

Python3

# Python program Implementing One Time Pad Algorithm

# Importing required classes
# Method 1
# Returning encrypted text


def stringEncryption(text, key):
    # Initializing cipherText
    cipherText = ""

    # Initialize cipher array of key length
    # which stores the sum of corresponding no.'s
    # of plainText and key.
    cipher = []
    for i in range(len(key)):
        cipher.append(ord(text[i]) - ord('A') + ord(key[i])-ord('A'))

    # If the sum is greater than 25
    # subtract 26 from it
    # and store that resulting value
    for i in range(len(key)):
        if cipher[i] > 25:
            cipher[i] = cipher[i] - 26

    # Converting the no.'s into integers
    # Convert these integers to corresponding
    # characters and add them up to cipherText

    for i in range(len(key)):
        x = cipher[i] + ord('A')
        cipherText += chr(x)

    # Returning the cipherText
    return cipherText


# Method 2
# Returning plain text
def stringDecryption(s, key):

    # Initializing plain text
    plainText = ""

    # Initializing integer array of key length
    # which stores difference
    # of corresponding no.'s of
    # each character of cipherText and key

    plain = []

    # Running for loop for each character
    # subtracting and storing in the array

    for i in range(len(key)):
        plain.append(ord(s[i]) - ord('A') - (ord(key[i]) - ord('A')))

    # If the difference is less than 0
    # add 26 and store it in the array.
    for i in range(len(key)):
        if (plain[i] < 0):
            plain[i] = plain[i] + 26

    # Converting int to corresponding char
    # add them up to plainText

    for i in range(len(key)):
        x = plain[i] + ord('A')
        plainText += chr(x)

    # Returning plainText
    return plainText


plainText = "Hello"

# Declaring key
key = "MONEY"

# Converting plain text to toUpperCase
# function call to stringEncryption
# with plainText and key as parameters

encryptedText = stringEncryption(plainText.upper(), key.upper())

# Printing cipher Text
print("Cipher Text - " + encryptedText)

# Calling above method to stringDecryption
# with encryptedText and key as parameters
print("Message - " + stringDecryption(encryptedText, key.upper()))

# This code is contributed by Pranay Arora

C#

// C# program Implementing One Time Pad Algorithm

using System;

public class GFG {
    public static String stringEncryption(String text,
                                          String key)
    {

        // Initializing cipherText
        String cipherText = "";

        // Initialize cipher array of key length
        // which stores the sum of corresponding no.'s
        // of plainText and key.
        int[] cipher = new int[key.Length];

        for (int i = 0; i < key.Length; i++) {
            cipher[i] = text[i] - 'A' + key[i] - 'A';
        }

        // If the sum is greater than 25
        // subtract 26 from it
        // and store that resulting value
        for (int i = 0; i < key.Length; i++) {
            if (cipher[i] > 25) {
                cipher[i] = cipher[i] - 26;
            }
        }

        // Converting the no.'s into integers

        // Convert these integers to corresponding
        // characters and add them up to cipherText
        for (int i = 0; i < key.Length; i++) {
            int x = cipher[i] + 'A';
            cipherText += (char)x;
        }

        // Returning the cipherText
        return cipherText;
    }
    // Method 2
    // Returning plain text
    public static String stringDecryption(String s,
                                          String key)
    {
        // Initializing plain text
        String plainText = "";

        // Initializing integer array of key length
        // which stores difference
        // of corresponding no.'s of
        // each character of cipherText and key
        int[] plain = new int[key.Length];

        // Running for loop for each character
        // subtracting and storing in the array
        for (int i = 0; i < key.Length; i++) {
            plain[i] = s[i] - 'A' - (key[i] - 'A');
        }

        // If the difference is less than 0
        // add 26 and store it in the array.
        for (int i = 0; i < key.Length; i++) {
            if (plain[i] < 0) {
                plain[i] = plain[i] + 26;
            }
        }

        // Converting int to corresponding char
        // add them up to plainText
        for (int i = 0; i < key.Length; i++) {
            int x = plain[i] + 'A';
            plainText += (char)x;
        }

        // Returning plainText
        return plainText;
    }

    // Method 3
    // Main driver method
    static void Main()
    {

        // Declaring plain text
        String plainText = "Hello";

        // Declaring key
        String key = "MONEY";

        // Converting plain text to toUpperCase
        // function call to stringEncryption
        // with plainText and key as parameters
        String encryptedText = stringEncryption(
            plainText.ToUpper(), key.ToUpper());

        // Printing cipher Text
        Console.WriteLine("Cipher Text - " + encryptedText);

        // Calling above method to stringDecryption
        // with encryptedText and key as parameters
        Console.WriteLine(
            "Message - "
            + stringDecryption(encryptedText,
                               key.ToUpper()));
    }
}
// This code is contributed by Pranay Arora

Javascript

// Method 1
// Returning encrypted text
function stringEncryption(text, key) {
    // Initializing cipherText
    let cipherText = "";

    // Initialize cipher array of key length
    // which stores the sum of corresponding no.'s
    // of plainText and key.
    let cipher = [];
    for (let i = 0; i < key.length; i++) {
        cipher[i] = text.charCodeAt(i) - 'A'.charCodeAt(0) + key.charCodeAt(i) - 'A'.charCodeAt(0);
    }

    // If the sum is greater than 25
    // subtract 26 from it
    // and store that resulting value
    for (let i = 0; i < key.length; i++) {
        if (cipher[i] > 25) {
            cipher[i] = cipher[i] - 26;
        }
    }

    // Converting the no.'s into integers

    // Convert these integers to corresponding
    // characters and add them up to cipherText
    for (let i = 0; i < key.length; i++) {
        let x = cipher[i] + 'A'.charCodeAt(0);
        cipherText += String.fromCharCode(x);
    }

    // Returning the cipherText
    return cipherText;
}

// Method 2
// Returning plain text
function stringDecryption(s, key) {
    // Initializing plain text
    let plainText = "";

    // Initializing integer array of key length
    // which stores difference
    // of corresponding no.'s of
    // each character of cipherText and key
    let plain = [];

    // Running for loop for each character
    // subtracting and storing in the array
    for (let i = 0; i < key.length; i++) {
        plain[i] = s.charCodeAt(i) - 'A'.charCodeAt(0) - (key.charCodeAt(i) - 'A'.charCodeAt(0));
    }

    // If the difference is less than 0
    // add 26 and store it in the array.
    for (let i = 0; i < key.length; i++) {
        if (plain[i] < 0) {
            plain[i] = plain[i] + 26;
        }
    }

    // Converting int to corresponding char
    // add them up to plainText
    for (let i = 0; i < key.length; i++) {
        let x = plain[i] + 'A'.charCodeAt(0);
        plainText += String.fromCharCode(x);
    }

    // Returning plainText
    return plainText;
}

// Method 3
// Main driver method
function main() {
    // Declaring plain text
    let plainText = "Hello";

    // Declaring key
    let key = "MONEY";

    // Converting plain text to toUpperCase
    // function call to stringEncryption
    // with plainText and key as parameters
    plainText = plainText.toUpperCase();
    key = key.toUpperCase();

    let encryptedText = stringEncryption(plainText, key);

    // Printing cipher Text
    console.log("Cipher Text - " + encryptedText);

    // Calling above method to stringDecryption
    // with encryptedText and key as parameters
    console.log("Message - " + stringDecryption(encryptedText, key));
}

// Call the main function
main();

Output

Cipher Text - TSYPM
Message - HELLO

Time Complexity: O(N)

Space Complexity: O(N)