Skip to content
Related Articles

Related Articles

Keyword Cipher

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 08 Dec, 2022
Improve Article
Save Article

Keyword cipher is a form of monoalphabetic substitution. A keyword is used as the key, and it determines the letter matchings of the cipher alphabet to the plain alphabet. Repeats of letters in the word are removed, then the cipher alphabet is generated with the keyword matching to A, B, C, etc. until the keyword is used up, whereupon the rest of the ciphertext letters are used in alphabetical order, excluding those already used in the key. 

Encryption:

The first line of input contains the keyword which you wish to enter. The second line of input contains the string which you have to encrypt.

Plaintext: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
Encrypted: K R Y P T O S A B C D E F G H I J L M N Q U V W X Z

With KRYPTOS as the keyword, all As become Ks, all Bs becoming Rs, and so on. Encrypting the message “knowledge is power” using the keyword “Kryptos”: 

Encrypting the message: Knowledge is Power 
Encoded message: IlmWjbaEb GQ NmWbp

Examples: 

Input :
Keyword : secret
Message : Zombie Here
Output :
Ciphered String : ZLJEFT DTOT
Take the first example, we used "secret" keyword there.
Plain Text : A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
When "secret" keyword is used, the new encrypting text becomes :
Encrypting : S E C R T A B D F G H I J K L M N O P Q U V W X Y Z
This means 'A' means 'S', 'B' means 'E' and 'C' means 'C' and so on.
Lets encode the given message "Zombie Here"
ZOMBIE HERE becomes ZLJEFT DTOT
Input :
Keyword : Star War
Message : Attack at dawn
Output :
Ciphered String : SPPSAG SP RSVJ

Few points to be noted in this method: 

  • All the messages are encoded in uppercase.
  • Whitespace, special characters, and numbers do not take into consideration keywords although you can put them in there.
  • While encrypting the message, whitespace, special characters and numbers remain unaffected.

Below is the implementation:

Output

Keyword : Computer
Message before Ciphering : GeeksforGeeks
Ciphered Text : EUUDNTILEUUDN

Decryption: 

To decode the message you check the position of the given message in encrypting text with the plain text.

Plaintext: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 
Encrypted: K R Y P T O S A B C D E F G H I J L M N Q U V W X Z
Message: PTYBIATLEP 
Deciphered Text: DECIPHERED

Now, how do we generate the deciphered string? We search for ‘P’ in Encrypted Text and compare its position with plain text letter and generate that letter. So ‘P’ becomes ‘D’, ‘T’ becomes ‘E’, ‘Y’ becomes ‘C’, and so on.

Examples: 

Input :
Keyword : secret
Message : zljeft dtOT
Output :
Deciphered String : ZOMBIE HERE

Input :
Keyword : joker0O7hack123
Message : QjTijl
Output :
Deciphered String : BATMAN

Below is the implementation:

Example 1

CPP




// CPP program for decoding the string
// which generate using classical cipher
 
#include <bits/stdc++.h>
using namespace std;
 
// Original Set of letters
string plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
// Function generates the encoded text
string encoder(string key)
{
    string encoded = "";
    bool arr[26] = { 0 };
 
    // This loop inserts the keyword
    // at the start of the encoded string
    for (int i = 0; i < key.size(); i++) {
        if (key[i] >= 'A' && key[i] <= 'Z') {
            // To check whether the character is inserted
            // earlier in the encoded string or not
            if (arr[key[i] - 65] == 0) {
                encoded += key[i];
                arr[key[i] - 65] = 1;
            }
        }
        else if (key[i] >= 'a' && key[i] <= 'z') {
            if (arr[key[i] - 97] == 0) {
                encoded += key[i] - 32;
                arr[key[i] - 97] = 1;
            }
        }
    }
 
    // This loop inserts the remaining
    // characters in the encoded string.
    for (int i = 0; i < 26; i++) {
        if (arr[i] == 0) {
            arr[i] = 1;
            encoded += char(i + 65);
        }
    }
    return encoded;
}
 
// This function will decode the message
string decipheredIt(string msg, string encoded)
{
    // Hold the position of every character (A-Z)
    // from encoded string
    map<char, int> enc;
    for (int i = 0; i < encoded.size(); i++) {
        enc[encoded[i]] = i;
    }
 
    string decipher = "";
 
    // This loop deciphered the message.
    // Spaces, special characters and numbers remain same.
    for (int i = 0; i < msg.size(); i++) {
        if (msg[i] >= 'a' && msg[i] <= 'z') {
            int pos = enc[msg[i] - 32];
            decipher += plaintext[pos];
        }
        else if (msg[i] >= 'A' && msg[i] <= 'Z') {
            int pos = enc[msg[i]];
            decipher += plaintext[pos];
        }
        else {
            decipher += msg[i];
        }
    }
    return decipher;
}
 
// Driver code
int main()
{
    // Hold the Keyword
    string key;
    key = "Computer";
    cout << "Keyword : " << key << endl;
 
    // Function call to generate encoded text
    string encoded = encoder(key);
 
    // Message that need to decode
    string message = "EUUDN TIL EUUDN";
    cout << "Message before Deciphering : " << message
         << endl;
 
    // Function call to print deciphered text
    cout << "Ciphered Text : "
         << decipheredIt(message, encoded) << endl;
 
    return 0;
}


Java




// Java program for decoding the string
// using classical cipher
  
import java.util.HashMap;
import java.util.Map;
 
class GFG
{
      
    // Function generates the encoded text
    public static String encoder(char[] key)
    {
        String encoded = "";
          
        // This array represents the
        // 26 letters of alphabets
        boolean[] arr = new boolean[26];
  
        // This loop inserts the keyword
        // at the start of the encoded string
        for (int i = 0; i < key.length; i++)
        {
            if (key[i] >= 'A' && key[i] <= 'Z')
            {
                // To check whether the character is inserted
                // earlier in the encoded string or not
                if (arr[key[i] - 65] == false)
                {
                    encoded += (char) key[i];
                    arr[key[i] - 65] = true;
                }
            }
            else if (key[i] >= 'a' && key[i] <= 'z')
            {
                if (arr[key[i] - 97] == false)
                {
                    encoded += (char) (key[i] - 32);
                    arr[key[i] - 97] = true;
                }
            }
        }
  
        // This loop inserts the remaining
        // characters in the encoded string.
        for (int i = 0; i < 26; i++)
        {
            if (arr[i] == false)
            {
                arr[i] = true;
                encoded += (char) (i + 65);
            }
        }
        return encoded;
    }
  
    // This function will decode the message
    public static String decipheredIt(String msg, String input)
    {
        // Original Set of letters
          String plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String decipher = "";
  
        // Hold the position of every character (A-Z) from encoded string
        Map<Character, Integer> enc = new HashMap<>();
        for (int i = 0; i < input.length(); i++)
        {
        enc.put(input.charAt(i), i);
        }
        // This loop deciphered the message.
        // Spaces, special characters and numbers remain same.
        for (int i = 0; i < msg.length(); i++)
        {
            if (msg.charAt(i) >= 'a' && msg.charAt(i) <= 'z')
            {
                int pos = enc.get((char)(msg.charAt(i)-32));
                decipher += plaintext.charAt(pos);
            }
            else if (msg.charAt(i) >= 'A' && msg.charAt(i) <= 'Z')
            {
                int pos = enc.get(msg.charAt(i));
                decipher += plaintext.charAt(pos);
            }
            else
            {
                decipher += msg.charAt(i);
            }
        }
        return decipher;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        // Hold the Keyword
        String key;
        key = "Computer";
        System.out.println("Keyword : " + key);
  
        // Function call to generate encoded text
        String decoded = encoder(key.toCharArray());
  
        // Message that need to encode
        String message = "EUUDN TIL EUUDN";
        System.out.println("Message before Deciphering : " + message);
  
        // Function call to print ciphered text
        System.out.println("Ciphered Text : " + decipheredIt(message,
                decoded));
    }
}
// This code is contributed by javierdsv


Python3




# Python program for decoding the string
# using classical cipher
import string
 
# stores all upper case alphabets
all_alphabets = list(string.ascii_uppercase)
 
# Function generates the encoded text
def encoder(key):
 
    encoded = ""
     
    # This array represents the
    # 26 letters of alphabets
    arr = [False]*26
 
    # This loop inserts the keyword
     # at the start of the encoded string
    for i in range(len(key)):
 
        if key[i] >= 'A' and key[i] <= 'Z':
           
            # To check whether the character is inserted
            # earlier in the encoded string or not
            if arr[ord(key[i]) - 65] == False:
                encoded += key[i]
                arr[ord(key[i]) - 65] = True
        elif key[i] >= 'a' and key[i] <= 'z':
            if arr[ord(key[i]) - 97] == False:
                encoded += chr(ord(key[i]) - 32)
                arr[ord(key[i]) - 97] = True
 
    # This loop inserts the remaining
    # characters in the encoded string.
    for i in range(26):
        if arr[i] == False:
            arr[i] = True
            encoded += (chr(i + 65))
 
    return encoded
 
 
# This function will decode the message
def decipheredIt(msg, encoded):
   
    # Original Set of letters
    plaintext = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    decipher = ""
     
    # Hold the position of every character (A-Z) from encoded string
    enc = {}
 
    for i in range(len(encoded)):
        enc[encoded[i]] = i
 
    # This loop deciphered the message.
    # Spaces, special characters and numbers remain same.
    for i in range(len(msg)):
        if msg[i] >= 'a' and msg[i] <= 'z':
            pos = enc.get((chr)(msg[i]-32))
            decipher += plaintext[pos]
 
        elif msg[i] >= 'A' and msg[i] <= 'Z':
            pos = enc.get(msg[i])
            decipher += plaintext[pos]
 
        else:
            decipher += msg[i]
 
    return decipher
 
# Hold the Keyword
key = "Computer"
print("Keyword : " + key)
 
# Function call to generate encoded text
decoded = encoder(list(key))
 
# Message that need to encode
message = "EUUDN TIL EUUDN"
print("Message before Deciphering : " + message)
 
# Function call to print ciphered text
print("Ciphered Text : " + decipheredIt(message, decoded))
 
# This code is contributed by arorapranay.


Output

Keyword : Computer
Message before Deciphering : EUUDN TIL EUUDN
Ciphered Text : GEEKS FOR GEEKS

Example 2

Python




# Python Program for Decoding the String
# using Classical Cipher
import string
 
# stores all upper case alphabets
all_alphabets = list(string.ascii_uppercase)
 
keyword = "Star War"
keyword1 = keyword.upper()
ciphertext = "SPPSAG SP RSVJ"
 
 
# converts message to list
ct = []
for i in ciphertext:
    ct.append(i.upper())
 
# removes default elements
 
 
def duplicates(list):
    key = []
    for i in list:
        if i not in key:
            key.append(i)
 
    return key
 
 
keyword1 = duplicates(keyword1)
 
# Stores the encryption list
encrypting = duplicates(keyword1+all_alphabets)
 
# removes spaces from the encryption list
for i in encrypting:
    if(i == ' '):
        encrypting.remove(' ')
 
# maps each element of the message to the encryption list and stores it in ciphertext
message = ""
for i in range(len(ct)):
    if(ct[i] != ' '):
        message = message+all_alphabets[encrypting.index(ct[i])]
    else:
        message = message+' '
 
print("Keyword : ", keyword)
print("Ciphered Text : ", ciphertext)
print("Message before Ciphering : ", message)


Output

('Keyword : ', 'Star War')
('Ciphered Text : ', 'SPPSAG SP RSVJ')
('Message before Ciphering : ', 'ATTACK AT DAWN')

Note: One can improve this Classical Cipher: Keyword also. Here we are only taking A-Z in plain text. You can take uppercase, lowercase, and numbers also into consideration.

Ways to attack a keyword cipher: 

The best ways to attack a keyword cipher without knowing the keyword are through the known-plaintext attack, frequency analysis, and discovery of the keyword (often a cryptanalyst will combine all three techniques). Keyword discovery allows immediate decryption since the table can be made immediately.

This article is contributed by Sachin Bisht. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!