Fix the code so that it can encrypt plaintext and decrypt ciphertext (S-DES)

import java.util.Scanner;

class InsideSDESFK {

//method 1

protected static int[] expanded = new int[8];

//method 2

protected static int[] xor8ed = new int[8];

//method 3

protected static int[] left2 = new int[4];

protected static int[] right2 = new int[4];

//method 4

protected static int indexR0;

protected static int indexR1;

protected static int indexR;

protected static int indexRDec;

protected static int indexC0;

protected static int indexC1;

protected static int indexC;

protected static int indexCDec;

protected final static int[][] s0= {{01, 00, 11, 10}, {11, 10, 01, 00}, {00, 10, 01, 11}, {11, 01, 11, 10}};

protected static int s0ValueNotSplit;

protected static int[] s0ValueSplit;

//method 5

protected final static int[][] s1= {{00, 01, 10, 11}, {10, 00, 01, 11}, {11, 00, 01, 10}, {10, 01, 00, 11}};

protected static int s1ValueNotSplit;

protected static int[] s1ValueSplit;

//method 6

protected static int[] combinedS0S1 = new int[4];

//method 7

protected static int[] p4ed = new int[4];

//method 8

protected static int[] xor4ed = new int[4];

public static void expand(int[] right) {

expanded[0] = right[3];

expanded[1] = right[0];

expanded[2] = right[1];

expanded[3] = right[2];

expanded[4] = right[1];

expanded[5] = right[2];

expanded[6] = right[3];

expanded[7] = right[0];

}

public static void xor8(int[] expanded, int[] k) {

for(int i = 0; i < xor8ed.length; i++) {

xor8ed[i] = expanded[i] ^ k[i];

}

}

public static void split2(int[] xor8) {

for(int i = 0; i

if(i < 4) {

left2[i] = xor8[i];

}

else {

right2[i-4] = xor8[i];

}

}

}

public static void splitS0(int[] left2) {

//row

indexR0 = left2[0];

indexR1 = left2[3];

indexR = Integer.valueOf(String.valueOf(indexR0) + String.valueOf(indexR1));

indexRDec = Integer.valueOf(indexR + "", 2);

//column

indexC0 = left2[1];

indexC1 = left2[2];

indexC = Integer.valueOf(String.valueOf(indexC0) + String.valueOf(indexC1));

indexCDec = Integer.valueOf(indexC + "", 2);

s0ValueNotSplit = s0[indexRDec][indexCDec];

s0ValueSplit = Integer.toString(s0ValueNotSplit).chars().map(c -> c-='0').toArray();

}

public static void splitS1(int[] right2) {

//row

indexR0 = right2[0];

indexR1 = right2[3];

indexR = Integer.valueOf(String.valueOf(indexR0) + String.valueOf(indexR1));

indexRDec = Integer.valueOf(indexR + "", 2);

//column

indexC0 = right2[1];

indexC1 = right2[2];

indexC = Integer.valueOf(String.valueOf(indexC0) + String.valueOf(indexC1));

indexCDec = Integer.valueOf(indexC + "", 2);

s1ValueNotSplit = s1[indexRDec][indexCDec];

s1ValueSplit = Integer.toString(s1ValueNotSplit).chars().map(c -> c-='0').toArray();

}

public static void combineS0S1(int[] s0ValueSplit, int[] s1ValueSplit) {

combinedS0S1[0] = s0ValueSplit[0];

combinedS0S1[1] = s0ValueSplit[1];

combinedS0S1[2] = s1ValueSplit[0];

combinedS0S1[3] = s1ValueSplit[1];

}

public static void p4(int[] combinedS0S1) {

p4ed[0] = combinedS0S1[1];

p4ed[1] = combinedS0S1[3];

p4ed[2] = combinedS0S1[2];

p4ed[3] = combinedS0S1[0];

}

public static void xor4(int[] p4ed, int[] left) {

for(int i = 0; i < xor4ed.length; i++) {

xor4ed[i] = p4ed[i] ^ left[i];

}

}

}

class SDESFunctions extends InsideSDESFK {

//method 1

protected static int[] permutated = new int[8];

//method 2

protected static int[] left = new int[4];

protected static int[] right = new int[4];

//method 3

//protected static int[] expanded;

//protected static int[] xor8ed;

//protected static int[] s0ValueSplit;

//protected static int[] s1ValueSplit;

//protected static int[] combinedS0S1;

//protected static int[] p4ed;

//protected static int[] fkXORed;

//method 4

protected static int[] combined2 = new int[8];

//method 5

protected static int[] inversePermutated = new int[8];

public static void initialPermutation(int[] text) {

permutated[0] = text[1];

permutated[1] = text[5];

permutated[2] = text[2];

permutated[3] = text[0];

permutated[4] = text[3];

permutated[5] = text[7];

permutated[6] = text[4];

permutated[7] = text[6];

}

public static void split(int[] permuated) {

for(int i = 0; i

if(i < 4) {

left[i] = permutated[i];

}

else {

right[i-4] = permutated[i];

}

}

}

public static void fk(int[] left, int[] right, int[] k) {

expand(right);

xor8(expanded, k);

split2(xor8ed);

splitS0(left2);

splitS1(right2);

combineS0S1(s0ValueSplit, s0ValueSplit);

p4(combinedS0S1);

xor4(p4ed, left);

}

public static void swap(int[] fkxored) {

left = right;

right = xor4ed;

}

public static void combine2(int[] xor4ed, int[] right) {

combined2[0] = xor4ed[0];

combined2[1] = xor4ed[1];

combined2[2] = xor4ed[2];

combined2[3] = xor4ed[3];

combined2[4] = right[0];

combined2[5] = right[1];

combined2[6] = right[2];

combined2[7] = right[3];

}

public static void inversePermutation(int[] combined2) {

inversePermutated[0] = combined2[3];

inversePermutated[1] = combined2[0];

inversePermutated[2] = combined2[2];

inversePermutated[3] = combined2[4];

inversePermutated[4] = combined2[6];

inversePermutated[5] = combined2[1];

inversePermutated[6] = combined2[7];

inversePermutated[7] = combined2[5];

}

}

public class sdes extends SDESFunctions {

//encrypt/ decrypt

//static int[] permutated;

//static int[] fkXOR;

//static int[] fkXOR2;

//static int[] combined2;

//static int[] inversePermutatedText;

public static int[] encrypt(int[] plaintext, int[] k, int[] k2) {

System.out.println("original plaintext");

initialPermutation(plaintext);

fk(left, right, k);

swap(xor4ed);

fk(left, right, k2);

combine2(xor4ed, right);

inversePermutation(combined2);

return inversePermutated;

}

public static int[] decrypt(int[] ciphertext, int[] k2, int[] k) {

System.out.println("ciphertext");

initialPermutation(ciphertext);

fk(left, right, k2);

swap(xor4ed);

fk(left, right, k);

combine2(xor4ed, right);

inversePermutation(combined2);

return inversePermutated;

}

public static void main(String[] args) {

Scanner in = new Scanner(System.in);

System.out.println("Enter plaintext");

int plaintextCombined = in.nextInt();

int[] plaintext = Integer.toString(plaintextCombined).chars().map(c -> c-='0').toArray();

System.out.println("Enter key for first round");

int kCombined = in.nextInt();

int [] kEnc = Integer.toString(kCombined).chars().map(c -> c-='0').toArray();

System.out.println("Enter key 2 for second round");

int k2CombinedEnc = in.nextInt();

int[] k2Enc = Integer.toString(k2CombinedEnc).chars().map(c -> c-='0').toArray();

int[] encrypted = encrypt(plaintext, kEnc, k2Enc);

for(int element: encrypted) {

System.out.println("encrypted ciphertext is" + element);

}

//decrypt

System.out.println("Enter ciphertext");

int ciphertextCombined = in.nextInt();

int[] ciphertext = Integer.toString(ciphertextCombined).chars().map(c -> c-='0').toArray();

System.out.println("Enter key 2 for first round");

int k2CombinedDec = in.nextInt();

int[] k2Dec = Integer.toString(k2CombinedDec).chars().map(c -> c-='0').toArray();

System.out.println("Enter key for second round");

int kCombinedDec = in.nextInt();

int[] kDec = Integer.toString(kCombinedDec).chars().map(c -> c-='0').toArray();

int[] decrypted = decrypt(ciphertext, k2Dec, kDec);

for(int element: decrypted) {

System.out.println("decrypted plaintext is" + element);

}

}

}