Solution ::

Answer:

code:

package letterfrequencydemo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/**
* LetterFrequencyAttackDemo class
*
*/
public class LetterFrequencyAttackDemo {

   private static char[] letters={'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'
   };

   //returns index of character in letters[]
   private static int getIndex(char c)
   {
       int index=-1;
       for(int i=0;i<letters.length;i++)
       {
           if(letters[i]==c)
           {
               index=i;
               break;
           }
       }
       return index;
   }

   //returns letter at a given index in letters[]
   private static char getLetter(int index)
   {
           return letters[index];
   }

   //reads plain text from stdin to encrypt
   public static String readPlainText() throws IOException
   {
       BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
       String plainText=reader.readLine();
       return plainText;
   }

   //encrypts a plain text based on general Ceaser cipher i.e. additive cipher
   public static String encrypt(String plainText, int key)
   {
       if(key < 1 || key > 25)
       {
           System.err.println("Invalid key");
           return plainText;
       }
       String encryptedText="";
       for(int i=0;i<plainText.length();i++)
       {
           char c=plainText.charAt(i);
           if(c!=' ')
           {
               int index=getIndex(c);
               int encryptedIndex=(index+key)%26;
               char cipherChar = getLetter(encryptedIndex);
               encryptedText+=cipherChar;
           }
           else
               encryptedText+=c;
       }
       return encryptedText;
   }

   //decrypts an encrypted text based on general Ceaser cipher i.e. additive cipher
   public static String decrypt(String encryptedText, int key)
   {
       if(key < 1 || key > 25)
       {
           System.err.println("Invalid key");
           return encryptedText;
       }
       String decryptedText="";
       /*for(int i=0;i<encryptedText.length();i++)
       {
           char c=encryptedText.charAt(i);
           if(c!=' ')
           {
               int index=getIndex(c);
               int decryptedIndex=(index-key)%26;
               if(decryptedIndex < 0)
                   decryptedIndex+=25;
               char decipherChar = getLetter(decryptedIndex);
               decryptedText+=decipherChar;
           }
           else
               encryptedText+=c;
           }*/
           decryptedText=encrypt(encryptedText, 26-key);
           return decryptedText;
       }
   /**
   * @param args
   * @throws IOException
   */
   public static void main(String[] args) throws IOException {
       System.out.println("Enter text:");
       String plainText=LetterFrequencyAttackDemo.readPlainText();
       System.out.println("Entered text is:"+plainText);
       //forcely change to lowercase
       plainText=plainText.toLowerCase();
       System.out.println("Performing encryption...");
       String encryptedText=LetterFrequencyAttackDemo.encrypt(plainText, 3);
       System.out.println("Encrypted text:"+encryptedText);
       System.out.println("Performing decryption with respect to all possible key combinations...");
       //25 keys to check
       for(int i=1;i<=25;i++)
       {
           String decryptedText=LetterFrequencyAttackDemo.decrypt(encryptedText, i);
           System.out.println("Decrypted text:"+decryptedText);
       }
   }

}

Output:

Enter text:
this is test plain text
Entered text is:this is test plain text
Performing encryption...
Encrypted text:wklv lv whvw sodlq whaw
Performing decryption with respect to all possible key combinations...
Decrypted text:vjku ku vguv rnckp vgzv
Decrypted text:uijt jt uftu qmbjo ufyu
Decrypted text:this is test plain text
Decrypted text:sghr hr sdrs okzhm sdws
Decrypted text:rfgq gq rcqr njygl rcvr
Decrypted text:qefp fp qbpq mixfk qbuq
Decrypted text:pdeo eo paop lhwej patp
Decrypted text:ocdn dn ozno kgvdi ozso
Decrypted text:nbcm cm nymn jfuch nyrn
Decrypted text:mabl bl mxlm ietbg mxqm
Decrypted text:lzak ak lwkl hdsaf lwpl
Decrypted text:kyzj zj kvjk gcrze kvok
Decrypted text:jxyi yi juij fbqyd junj
Decrypted text:iwxh xh ithi eapxc itmi
Decrypted text:hvwg wg hsgh dzowb hslh
Decrypted text:guvf vf grfg cynva grkg
Decrypted text:ftue ue fqef bxmuz fqjf
Decrypted text:estd td epde awlty epie
Decrypted text:drsc sc docd zvksx dohd
Decrypted text:cqrb rb cnbc yujrw cngc
Decrypted text:bpqa qa bmab xtiqv bmfb
Decrypted text:aopz pz alza wshpu alea
Decrypted text:znoy oy zkyz vrgot zkdz
Decrypted text:ymnx nx yjxy uqfns yjcy
Decrypted text:xlmw mw xiwx tpemr xibx

Please provide your valuable feedback.

Public Answer