encrypt.java

this progam written in java language and describe the des algorithm that allow us to encrypt and de

 /*
 *   *       Please Visit us at www.codemiles.com     *
 *  This Program was Developed by www.codemiles.com forums Team
 *  *           Please Don't Remove This Comment       *
 */
 
public class encrypt {
    
    /** Creates a new instance of encrypt */
    public encrypt(  String Plaintext, String Key) {
        
        
        
        
        PlainText=Plaintext;
        keyword=Key;
        
        
    }
    
    public String CheckLenPlain(String plain){
        if(plain.length()%8!=0) {
            int len=8-plain.length()%8;
            
            for(int i=0; i<len; i++)
                plain=plain.concat("*");
            
        } else {
            return plain;
        }
        return plain;
        
    }
    
    
    public void DoEncrpyt_Plaintext(String plain) {
        
        for(int i=0;i<8&&i<plain.length();i++) {
            block[i]=getBinaryBits(plain.charAt(i));// 2D array [8][8]
            
        }
        int index=0;
        for(int i=0; i<8; i++){
            for(int j=0; j<8;j++){
                perm[index]=(int)block[i][j];
                blockS[i][j]=Integer.toString((int)block[i][j]);
                index++;
                
            }
        }
        arrayprinter.printarray(blockS,"PlainText Text in Binary");
        DesPanel.StepsText.append("****************************************************************"+'\n');
        
    }
    
    
    public void DoEncrpyt_keyword() {
        
        
        
        for(int i=0;i<8&&i<keyword.length();i++) {
            block[i]=getBinaryBits(keyword.charAt(i));
            for(int j=0;j<8;j++) {
                
                blockS[i][j]=Integer.toString((int)block[i][j]);
                
                
            }
            //  System.out.println(" ");
        }
        
        
        int index=0;
        for(int i=0; i<8; i++){
            for(int j=0; j<8;j++){
                key_in[index]=(int)block[i][j];
                index++;
                
            }
        }
        
        arrayprinter.printarray(blockS,"KeyWord Text in Binary");
        DesPanel.StepsText.append("****************************************************************"+'\n');
        
    }
    
    public byte[] getBinaryBits(int ch) {
        byte[] bin=new byte[8];
        int tag=1;
        for(int i=0;i<8;i++) {
            bin[7-i]=(byte)((ch&((tag<<i)))>>i);
        }
        return bin;
    }
    
    public void DoSegmentation(int[] perm_out){
        int index=0;
        for(int i=0; i<32; i++)
            Left[i]=perm_out[i];
        
        for(int i=32; i<64; i++){
            Right[index]=perm_out[i];
            
            index++;
        }
        index=0;
        for(int i=0; i<4;i++){
            for(int j=0; j<8; j++){
                LeftS[i][j]=Integer.toString(Left[index]);
                RightS[i][j]=Integer.toString(Right[index]);
                index++;
            }
        }
        arrayprinter.printarray(LeftS,"Left Part");
        arrayprinter.printarray(RightS,"Right Part");
        
    }
    public void XOR(int side1[], int [] side2,int [] result){
        int index=0;
        for(int i=0; i<side1.length; i++){
            if(side1[i]==side2[i])
                result[index]=0;
            else
                result[index]=1;
            index++;
            
        }
        
        
        
        
        
    }
    public void FillC_D(){
        int index=28;
        for(int i=0; i<28; i++)
            C_D[i]=C[i];
        
        for(int i=0; i<28; i++){
            C_D[index]=D[i];
            index++;
        }
        
        
    }
    public void contancate() {
        int index=32;
        for(int i=0; i<32; i++)
            Block64[i]=Left[i];
        
        for(int i=0; i<32; i++){
            Block64[index]=Right[i];
            index++;
        }
    }
    public void swap32() {
        int temp;
        for(int i=0;i<32;i++) {
            temp=Left[i];
            Left[i]=Right[i];
            Right[i]=temp;
        }
        ind=0;
        for(int i=0; i<4;i++){
            for(int j=0; j<8; j++){
                LeftS[i][j]=Integer.toString(Left[ind]);
                RightS[i][j]=Integer.toString(Right[ind]);
                ind++;
            }
        }
        arrayprinter.printarray(LeftS,"Left Part");
        arrayprinter.printarray(RightS,"Right Part");
        ind=0;
    }
    
    public static int[] getByteFromBits(int bits64[]) {
        // int ch[]=new int[8];
        int index=0;
        System.out.println();
        for(int i=0;i<8;i++)
            for(int j=1;j<=8;j++) {
            
            
            ch[i]+=(int)Math.pow(2,(8-j))*bits64[index];
            index++;
            
            }
        
        return ch;
    }
    
    public void Chooser(int choice){
        if(choice==1){
            System.out.println("before One left shift " + index);
            for(int j=0; j<C.length; j++)
                System.out.print(C[j]);
            key.Do_OneLeftShitf(C,D);
            System.out.println();
            System.out.println("After One left shift " + index);
            for(int j=0; j<C.length; j++)
                System.out.print(C[j]);
        }
        
        else{
            
            for(int j=0; j<C.length; j++)
                System.out.print(C[j]);
            
            key.Do_OneLeftShitf(C,D);
            key.Do_OneLeftShitf(C,D);
            System.out.println(" LEFT= ");
            
            for(int j=0; j<C.length; j++)
                System.out.print(C[j]);
            
            System.out.println(" Right= ");
            
            for(int j=0; j<D.length; j++)
                System.out.print(D[j]);
            
        }
        
    }
    
    public void DoDecryption() {
        DesPanel.StepsText.append("************************DECIPHER***********************************"+'\n');
        int start=0;
      
        int counter=0;
        int end=64;
        for(int f=0; f<PlainText.length()/8; f++){
            
              int Round=1;
            for(int h=start; h<end; h++ ){
                newBlock64_[counter]=Integer.parseInt(finalEncry.substring(h,h+1));
                counter++;
            }
            DesPanel.StepsText.append("*********Block Number *********"+(f+1)+'\n');
            ind=0;
            DesPanel.StepsText.append("*********Cipher Block In Round ********* "+ Round+'\n');
            for(int d=0 ; d<8; d++){
                for(int j=0; j<8; j++){
                    newBlock64_S[d][j]=Integer.toString(newBlock64[ind]);
                    ind++;
                }
            }
            arrayprinter.printarray(newBlock64_S,"Cipher Block");
            
            
            
            p= new Permutation();
            
            p.FillPermutation();//step1 from 2D to 1D
            p.DoIP(newBlock64_,perm_out);
            DoSegmentation(perm_out);
            
            int adder=48;
            
            while(Round<=16) {
                DesPanel.StepsText.append("*********Round Number********* "+Round+'\n');
                for(int i=0; i<48; i++) {
                    reversedkey[i]=Integer.parseInt(key_reverse.substring((key_reverse.length()-adder)+i,(key_reverse.length()-adder)+i+1));
                    
                }
                System.out.println();
                ESTable Etable = new ESTable();
                Etable.FillETable();//step3 array from 2D to 1D
                Etable.DoETable(Right,Right_out);//step3
                DesPanel.StepsText.append("*********Right Part XORED with Round Key********* "+Round+'\n');
                XOR(Right_out,reversedkey,XOR_Out);//step1
                ind=0;
                for(int g=0; g<6; g++){
                    for(int j=0; j<8; j++){
                        XORS[g][j]=Integer.toString(XOR_Out[ind]);
                        ind++;
                        
                    }
                }
                arrayprinter.printarray(XORS,"XOR Result");
                ind=0;
                SBox sbox= new SBox();
                
                sbox.DoSBox(XOR_Out,after_SBox);//step2 32bits - include permitation
                DesPanel.StepsText.append("*********Left Part XORED with Output Function in Round********* "+Round+'\n');
                XOR(Left,after_SBox,aft_XOR_fuc);//XOR
                
                
                
                for(int g=0; g<4; g++){
                    for(int j=0; j<8; j++){
                        aft_XOR_fucS[g][j]=Integer.toString(aft_XOR_fuc[ind]);
                        ind++;
                        
                    }
                }
                ind=0;
                arrayprinter.printarray(aft_XOR_fucS,"XOR Result");
                
                adder=adder+48;
                Round++;
                DesPanel.StepsText.append("*********Left=Right & Right=Left*********"+'\n');