cryptography
Playfair सिफर

परिचय

एन्क्रिप्शन और डिक्रिप्शन नियम के साथ Playfair सिफर एन्क्रिप्शन का उदाहरण

एक कीवर्ड "MONARCHY" है फिर मैट्रिक्स जैसा दिखेगा

मैट्रिक्स का निर्माण कीवर्ड के अक्षरों (माइनस डुप्लिकेट) को बाएं से दाएं और ऊपर से नीचे तक भरने के द्वारा किया जाता है, और फिर मैट्रिक्स के शेष अक्षरों में वर्णमाला के क्रम में शेष के साथ भरना होता है। निम्नलिखित नियमों के अनुसार, एक समय में दो अक्षरों को प्लेनटेक्स्ट एन्क्रिप्ट किया गया है:

1. पाठ (प्लेन / सिफर) के पात्रों को लें और दो वर्णों का एक समूह बनाएं। यदि पाठ में वर्णों की संख्या विषम है, तो एक भराव पत्र जोड़ें (आमतौर पर हम 'x' का उपयोग करते हैं)।
   पाठ = "हेलो" तब यह समूह के रूप में होगा
   वह | एलएल | OX

2. मैट्रिक्स के एक ही पंक्ति में पड़ने वाले दो प्लेनटेक्स्ट अक्षर प्रत्येक को अक्षर द्वारा दाईं ओर पंक्ति के पहले तत्व के साथ अंतिम रूप से अनुसरण करते हैं। उदाहरण के लिए, आरएम को आरएम के रूप में एन्क्रिप्ट किया गया है।

3. एक ही कॉलम में आने वाले दो प्लेनटेक्स्ट अक्षर प्रत्येक के नीचे अक्षर द्वारा प्रतिस्थापित किए जाते हैं, कॉलम के शीर्ष तत्व को अंतिम रूप से अंतिम रूप से देखा जाता है। उदाहरण के लिए, म्यू को सीएम के रूप में एन्क्रिप्ट किया गया है।

4. अन्यथा, एक जोड़ी में प्रत्येक सादे पत्र को उस पत्र से बदल दिया जाता है जो अपनी पंक्ति में निहित होता है और अन्य सादे पत्र द्वारा कब्जा किए गए कॉलम। इस प्रकार, hs BP बन जाता है और ea IM (या JM हो जाता है, जैसा कि ईर्ष्या करने वाला चाहता है)।

एक साधारण जावा प्रोग्राम जो प्लेफेयर सिफर को लागू करता है, नीचे दिया गया है:

import java.util.Scanner;


public class Playfair {
public static void main(String[] args) {
    Scanner in=new Scanner(System.in);

    System.out.print("Enter keyword: ");
    String key=in.nextLine();
    System.out.print("Enter message to encrypt: ");
    String msg=in.nextLine();

    PFEncryption pfEncryption=new PFEncryption();
    pfEncryption.makeArray(key);
    msg=pfEncryption.manageMessage(msg);
    pfEncryption.doPlayFair(msg, "Encrypt");
    String en=pfEncryption.getEncrypted();
    System.out.println("Encrypting....\n\nThe encrypted text is: " + en);
    System.out.println("=======================================");
    pfEncryption.doPlayFair(en, "Decrypt");
    System.out.print("\nDecrypting....\n\nThe encrypted text is: " + pfEncryption.getDecrypted());
}
}

class PFEncryption{

private char [][] alphabets= new char[5][5];
private char[] uniqueChar= new char[26];
private String ch="ABCDEFGHIKLMNOPQRSTUVWXYZ";
private String encrypted="";
private String decrypted="";

void makeArray(String keyword){
    keyword=keyword.toUpperCase().replace("J","I");
    boolean present, terminate=false;
    int val=0;
    int uniqueLen;
    for (int i=0; i<keyword.length(); i++){
        present=false;
        uniqueLen=0;
        if (keyword.charAt(i)!= ' '){
            for (int k=0; k<uniqueChar.length; k++){
                if (Character.toString(uniqueChar[k])==null){
                    break;
                }
                uniqueLen++;
            }
            for (int j=0; j<uniqueChar.length; j++){
                if (keyword.charAt(i)==uniqueChar[j]){
                    present=true;
                }
            }
            if (!present){
                uniqueChar[val]=keyword.charAt(i);
                val++;
            }
        }
        ch=ch.replaceAll(Character.toString(keyword.charAt(i)), "");
    }

    for (int i=0; i<ch.length(); i++){
        uniqueChar[val]=ch.charAt(i);
        val++;
    }
    val=0;

    for (int i=0; i<5; i++){
        for (int j=0; j<5; j++){
            alphabets[i][j]=uniqueChar[val];
            val++;
            System.out.print(alphabets[i][j] + "\t");
        }
        System.out.println();
    }
    }

    String manageMessage(String msg){
    int val=0;
    int len=msg.length()-2;
    String newTxt="";
    String intermediate="";
    while (len>=0){
        intermediate=msg.substring(val, val+2);
        if (intermediate.charAt(0)==intermediate.charAt(1)){
            newTxt=intermediate.charAt(0) + "x" + intermediate.charAt(1);
            msg=msg.replaceFirst(intermediate, newTxt);
            len++;
        }
        len-=2;
        val+=2;
    }

    if (msg.length()%2!=0){
        msg=msg+'x';
        }
        return msg.toUpperCase().replaceAll("J","I").replaceAll(" ","");
    }

void doPlayFair(String msg, String tag){
    int val=0;
    while (val<msg.length()){
        searchAndEncryptOrDecrypt(msg.substring(val, val + 2), tag);
        val+=2;
    }
}

void searchAndEncryptOrDecrypt(String doubblyCh, String tag){
    char ch1=doubblyCh.charAt(0);
    char ch2=doubblyCh.charAt(1);
    int row1=0, col1=0, row2=0, col2=0;
    for (int i=0; i<5; i++){
        for (int j=0; j<5; j++){
            if (alphabets[i][j]==ch1){
                row1=i;
                col1=j;
            }else if (alphabets[i][j]==ch2){
                row2=i;
                col2=j;
            }
        }
    }
    if (tag=="Encrypt")
        encrypt(row1, col1, row2, col2);
    else if(tag=="Decrypt")
        decrypt(row1, col1, row2, col2);
}

void encrypt(int row1, int col1, int row2, int col2){
    if (row1==row2){
        col1=col1+1;
        col2=col2+1;
        if (col1>4)
            col1=0;
        if (col2>4)
            col2=0;
        encrypted+=(Character.toString(alphabets[row1][col1])+Character.toString(alphabets[row1][col2]));
    }else if(col1==col2){
        row1=row1+1;
        row2=row2+1;
        if (row1>4)
            row1=0;
        if (row2>4)
            row2=0;
        encrypted+=(Character.toString(alphabets[row1][col1])+Character.toString(alphabets[row2][col1]));
    }else{
        encrypted+=(Character.toString(alphabets[row1][col2])+Character.toString(alphabets[row2][col1]));
    }
}

void decrypt(int row1, int col1, int row2, int col2){
    if (row1==row2){
        col1=col1-1;
        col2=col2-1;
        if (col1<0)
            col1=4;
        if (col2<0)
            col2=4;
        decrypted+=(Character.toString(alphabets[row1][col1])+Character.toString(alphabets[row1][col2]));
    }else if(col1==col2){
        row1=row1-1;
        row2=row2-1;
        if (row1<0)
            row1=4;
        if (row2<0)
            row2=4;
        decrypted+=(Character.toString(alphabets[row1][col1])+Character.toString(alphabets[row2][col1]));
    }else{
        decrypted+=(Character.toString(alphabets[row1][col2])+Character.toString(alphabets[row2][col1]));
    }
}

String getEncrypted(){
    return encrypted;
}
String getDecrypted(){
    return decrypted;
}



}