Translate To Preferred Language

Search ObiokusThoughts

Please Read Today's Featured Post

Law of Attraction

When considering the concept of the “law of attraction”, I simply reduce it to the exercise of unity progress.  As you find something that...

Template for AES Encryption in Java (some bugs may occur)


/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package aes;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.Scanner;
import javax.crypto.*;
import java.security.*;
import java.security.cert.*;
import java.security.cert.X509Certificate;
import java.security.cert.X509Extension;
import java.util.Arrays;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 *
 * @author obobotette0
 */
public class AES {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws FileNotFoundException, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidAlgorithmParameterException, UnsupportedEncodingException, IOException, NoSuchProviderException, CertificateException {
        // TODO code application logic here

        //create variables
        //String inFile = "..\\AES\\src\\aes\\input (another sample)(11).txt";
        String inFile = "..\\AES\\src\\aes\\input(11).txt";
        String outFile = "..\\AES\\src\\aes\\outputas1.txt";
        String irpoly = new String();
        String key = new String();
        String plaintext = new String();
        String ciphertext = new String();
        String print0 = new String();
        String print1 = new String();
        StringBuffer concat0 = new StringBuffer();
        StringBuffer concat1 = new StringBuffer();
        StringBuffer concat2 = new StringBuffer();
        StringBuffer concat3 = new StringBuffer();
        StringBuffer concat4 = new StringBuffer();
        int mod = 0;

        //Read text file
        File input = new File(inFile);
        Scanner read = new Scanner(input);

        //Assign lines as suggested
        if (read.hasNextLine()) {
            irpoly = "0000000" + read.nextLine();
            key = read.nextLine();
            plaintext = read.nextLine();
            ciphertext = read.nextLine();
        }

        read.close();

        //Prepare write file
        FileWriter output = new FileWriter(outFile);
        PrintWriter write = new PrintWriter(output);

        irpoly = irpoly.replace(" ", "");
       
        //Variables for the java library
        //Divide each string into two parts
        String key0 = key.substring(0, 16);       
        String key1 = key.substring(16);
       
        String plaintext0 = plaintext.substring(0, 16);       
        String plaintext1 = plaintext.substring(16);
        
        String ciphertext0 = ciphertext.substring(0, 16);       
        String ciphertext1 = ciphertext.substring(16);
       
        //Variables for the scripted portion
        int k[] = new int[key.length() / 2];
        int p[] = new int[key.length() / 2];
        int c[] = new int[key.length() / 2];
        int[][] keymatrix = new int[4][4];
        int[][] plainmatrix = new int[4][4];
        int[][] ciphermatrix = new int[4][4];
        int[][] result = new int[4][4];
        int[][] newkey = new int[4][4];
       
        //Loop to convert 32 chars to 16 ints
        for (int i = 0; i < key.length(); i += 2) {
           
            k[i / 2] = Integer.parseInt(String.valueOf(key.codePointAt(i)),16)*16 + Integer.parseInt(String.valueOf(key.codePointAt(i + 1)),16);
            p[i / 2] = Integer.parseInt(String.valueOf(plaintext.codePointAt(i)),16)*16 + Integer.parseInt(String.valueOf(plaintext.codePointAt(i + 1)),16);
            c[i / 2] = Integer.parseInt(String.valueOf(ciphertext.codePointAt(i)),16)*16 + Integer.parseInt(String.valueOf(ciphertext.codePointAt(i + 1)),16);
           
        }
        System.out.println(k.length + " k " + Arrays.toString(k));
        System.out.println(key.length() + " key " + key);

        //loop to create matrix for transformations
        for (int i = 0; i < k.length; i++) {

            keymatrix[i / 4][i % 4] = k[i];
            plainmatrix[i / 4][i % 4] = p[i];
            ciphermatrix[i / 4][i % 4] = c[i];
           
        }
       
        //Variables for transformations
        int[][] mixcol = {{02, 03, 01, 01}, {01, 02, 03, 01}, {01, 01, 02, 03}, {03, 01, 01, 02}};
        int[][] invmixcol = {{Integer.parseInt("0e", 16), Integer.parseInt("0b", 16), Integer.parseInt("0d", 16), Integer.parseInt("09", 16)},
        {Integer.parseInt("09", 16), Integer.parseInt("0e", 16), Integer.parseInt("0b", 16), Integer.parseInt("0d", 16)},
        {Integer.parseInt("0d", 16), Integer.parseInt("09", 16), Integer.parseInt("0e", 16), Integer.parseInt("0b", 16)},
        {Integer.parseInt("0b", 16), Integer.parseInt("0d", 16), Integer.parseInt("09", 16), Integer.parseInt("0e", 16)}};
        AlgorithmParameters algo0 = AlgorithmParameters.getInstance("AES");
        IvParameterSpec iv0 = new IvParameterSpec(irpoly.getBytes("UTF-8"));
        SecretKeySpec skey0 = new SecretKeySpec(key0.getBytes("UTF-8"), "AES");
        SecretKeySpec skey1 = new SecretKeySpec(key1.getBytes("UTF-8"), "AES");
       
        //Tried two different block ciphers
        Cipher transform = Cipher.getInstance("AES/ECB/NoPadding");
        Cipher transform2 = Cipher.getInstance("AES/CBC/NoPadding");
       
        //Show plaintext
        write.append("Plaintext " + plaintext);
        write.println();
       
       
        //Loop for scripted AES process
        for (int i = 0; i <= 10; i++) {
            if (i == 0) {
                newkey = keyexpansion(keymatrix, irpoly, i);
                result = addroundkey(plainmatrix, newkey);
                //System.out.println(i);
            } else if (i > 0 && i < 10) {
                result = subbytes(result);
                result = shiftrows(result);
                result = mixcolumns(result, mixcol, irpoly);
                newkey = keyexpansion(newkey, irpoly, i);
                result = addroundkey(result, newkey);
                //System.out.println(i);
            } else if (i == 10) {
                result = subbytes(result);
                result = shiftrows(result);
                newkey = keyexpansion(newkey, irpoly, i);
                result = addroundkey(result, newkey);
                //System.out.println(i);
            }
        }
        System.out.println(Integer.parseInt(irpoly, 2) + " nums " + irpoly);
        System.out.println(keymatrix.length + " matrix " + Arrays.deepToString(keymatrix));
        System.out.println(plainmatrix.length + " plain " + Arrays.deepToString(plainmatrix));
        //Return absolute value of matrix cell as a value from 0 to 255
        for (int i = 0; i < 16; i++){
            concat0.append(Integer.toHexString(Math.abs(result[i/4][i%4]%256)));
        }
        System.out.println(result.length + " result " + Arrays.deepToString(result));
        System.out.println(concat0.length() + " concat " + concat0);
        //Print results
        write.append("Manual encryption AES " + concat0);
        write.println();
        //transform.init(Cipher.WRAP_MODE, skey0);
        //transform.init(Cipher.WRAP_MODE, skey1);
        //Java library encryption with ECB
         transform.init(Cipher.ENCRYPT_MODE, skey0);
         byte[] encText0 = transform.doFinal(plaintext0.getBytes("UTF-8"));
         transform.init(Cipher.ENCRYPT_MODE, skey1);
         byte[] encText1 = transform.doFinal(plaintext1.getBytes("UTF-8"));
         //Loop to print result
         for (int i = 0; i < 32; i++) {
         if (i < 16) {
         concat4.append(Integer.toHexString(Math.abs(encText0[i] % 16)));
         } else {
         concat4.append(Integer.toHexString(Math.abs(encText1[i % 16] % 16)));
         }
         }
         System.out.println(encText0.length + encText1.length);
         System.out.println(Arrays.toString(encText0) + Arrays.toString(encText1));
         System.out.println(concat4);
         write.append("AES encryption using ECB " + concat4);
         write.append("\n");
         //System.out.println(Arrays.toString(result));
         //transform2.init(Cipher.WRAP_MODE, skey0, iv0);
         //transform2.init(Cipher.WRAP_MODE, skey1, iv0);
         //Java library with CBC
         transform2.init(Cipher.ENCRYPT_MODE, skey0, iv0);
         encText0 = transform2.doFinal(plaintext0.getBytes("UTF-8"));
         transform2.init(Cipher.ENCRYPT_MODE, skey1, iv0);
         encText1 = transform2.doFinal(plaintext1.getBytes("UTF-8"));
         //Loop to print result
         for (int i = 0; i < 32; i++) {

         if (i < 16) {
         concat1.append(Integer.toHexString(Math.abs(encText0[i] % 16)));
         } else {
         concat1.append(Integer.toHexString(Math.abs(encText1[i % 16] % 16)));
         }
         }
         System.out.println(encText0.length + encText1.length);
         System.out.println(Arrays.toString(encText0) + Arrays.toString(encText1));
         System.out.println(concat1);
         write.append("AES encryption using CBC " + concat1);
         write.append("\n");
         //System.out.println(Arrays.toString(result));
         //Decryption with ECB
         transform.init(Cipher.DECRYPT_MODE, skey0);//, iv0);
         byte[] decText0 = transform.doFinal(ciphertext0.getBytes("UTF-8"));
         transform.init(Cipher.DECRYPT_MODE, skey1);//, iv1);
         byte[] decText1 = transform.doFinal(ciphertext1.getBytes("UTF-8"));
         //byte[] decText0 = transform.doFinal(encText0);
         //byte[] decText1 = transform.doFinal(encText1);
         for (int i = 0; i < 32; i++) {

         if (i < 16) {
         concat2.append(Integer.toHexString(Math.abs(decText0[i] % 16)));
         } else {
         concat2.append(Integer.toHexString(Math.abs(decText1[i % 16] % 16)));
         }
         }
         System.out.println(decText0.length + decText1.length);
         System.out.println(Arrays.toString(decText0) + Arrays.toString(decText1));
         System.out.println(concat2);
         write.append("AES decryption using ECB " + concat2);
         write.append("\n");
         //System.out.println(Arrays.toString(result));   
         //Decryption with CBC
         transform2.init(Cipher.DECRYPT_MODE, skey0, iv0);
         decText0 = transform2.doFinal(ciphertext0.getBytes("UTF-8"));
         transform2.init(Cipher.DECRYPT_MODE, skey1, iv0);
         decText1 = transform2.doFinal(ciphertext1.getBytes("UTF-8"));
         //decText0 = transform2.doFinal(encText0);
         //decText1 = transform2.doFinal(encText1);
         for (int i = 0; i < 32; i++) {

         if (i < 16) {
         concat3.append(Integer.toHexString(Math.abs(decText0[i] % 16)));
         } else {
         concat3.append(Integer.toHexString(Math.abs(decText1[i % 16] % 16)));
         }
         }
         System.out.println(decText0.length + decText1.length);
         System.out.println(Arrays.toString(decText0) + Arrays.toString(decText1));
         System.out.println(concat3);
         write.append("AES decryption using CBC " + concat3);
         write.append("\n");
        //Expected result
        write.append("Expected cipher result " + ciphertext);
        write.println();
        write.flush();
        //System.out.println(Arrays.toString(result));      

    }

    public static int[][] subbytes(int[][] text) {
        String[] swap0 = {"63", "7c", "77", "7b", "f2", "6b", "6f", "c5", "30", "01", "67", "2b", "fe", "d7", "ab", "76"
            + "ca", "82", "c9", "7d", "fa", "59", "47", "f0", "ad", "d4", "a2", "af", "9c", "a4", "72", "c0"
            + "b7", "fd", "93", "26", "36", "3f", "f7", "cc", "34", "a5", "e5", "f1", "71", "d8", "31", "15"
            + "04", "c7", "23", "c3", "18", "96", "05", "9a", "07", "12", "80", "e2", "eb", "27", "b2", "75"
            + "09", "83", "2c", "1a", "1b", "6e", "5a", "a0", "52", "3b", "d6", "b3", "29", "e3", "2f", "84"
            + "53", "d1", "00", "ed", "20", "fc", "b1", "5b", "6a", "cb", "be", "39", "4a", "4c", "58", "cf"
            + "d0", "ef", "aa", "fb", "43", "4d", "33", "85", "45", "f9", "02", "7f", "50", "3c", "9f", "a8"
            + "51", "a3", "40", "8f", "92", "9d", "38", "f5", "bc", "b6", "da", "21", "10", "ff", "f3", "d2"
            + "cd", "0c", "13", "ec", "5f", "97", "44", "17", "c4", "a7", "7e", "3d", "64", "5d", "19", "73"
            + "60", "81", "4f", "dc", "22", "2a", "90", "88", "46", "ee", "b8", "14", "de", "5e", "0b", "db"
            + "e0", "32", "3a", "0a", "49", "06", "24", "5c", "c2", "d3", "ac", "62", "91", "95", "e4", "79"
            + "e7", "c8", "37", "6d", "8d", "d5", "4e", "a9", "6c", "56", "f4", "ea", "65", "7a", "ae", "08"
            + "ba", "78", "25", "2e", "1c", "a6", "b4", "c6", "e8", "dd", "74", "1f", "4b", "bd", "8b", "8a"
            + "70", "3e", "b5", "66", "48", "03", "f6", "0e", "61", "35", "57", "b9", "86", "c1", "1d", "93"
            + "e1", "f8", "98", "11", "69", "d9", "8e", "94", "9b", "1e", "87", "e9", "ce", "55", "28", "df"
            + "8c", "a1", "89", "0d", "bf", "e6", "42", "68", "41", "99", "2d", "0f", "b0", "54", "bb", "16"};
       
        for (int i = 0; i < 16; i++) {
            for (int j = 0; j < swap0.length; j++) {
                //if array element is equal to j
                if (text[i / 4][i % 4] == j) {
                    //swap with j element of sbox transformation
                    text[i / 4][i % 4] = Integer.parseInt(swap0[j], 16);
                }
            }
        }

        return text;
    }

    public static int[][] invsubbytes(int[][] text) {
        String[] swap0 = {"52", "09", "6a", "d5", "30", "36", "a5", "38", "bf", "40", "a3", "9e", "81", "f3", "d7", "fb"
            + "7c", "e3", "39", "82", "9b", "2f", "ff", "87", "34", "8e", "43", "44", "c4", "de", "e9", "cb"
            + "54", "7b", "94", "32", "a6", "c2", "23", "3d", "ee", "4c", "95", "0b", "42", "fa", "c3", "4e"
            + "08", "2e", "a1", "66", "28", "d9", "24", "b2", "76", "5b", "a2", "49", "6d", "8b", "d1", "25"
            + "72", "f8", "f6", "64", "86", "68", "98", "16", "d4", "a4", "5c", "cc", "5d", "65", "b6", "92"
            + "6c", "70", "48", "50", "fd", "ed", "b9", "da", "5e", "15", "46", "57", "a7", "8d", "9d", "84"
            + "90", "d8", "ab", "00", "8c", "bc", "d3", "0a", "f7", "e4", "58", "05", "b8", "b3", "45", "06"
            + "d0", "2c", "1e", "8f", "ca", "3f", "0f", "02", "c1", "af", "bd", "03", "01", "13", "8a", "6b"
            + "3a", "91", "11", "41", "4f", "67", "dc", "ea", "97", "f2", "cf", "ce", "f0", "b4", "e6", "73"
            + "96", "ac", "74", "22", "e7", "ad", "35", "85", "e2", "f9", "37", "e8", "1c", "75", "df", "6e"
            + "47", "f1", "1a", "71", "1d", "29", "c5", "89", "6f", "b7", "62", "0e", "aa", "18", "be", "1b"
            + "fc", "56", "3e", "4b", "c6", "d2", "79", "20", "9a", "db", "c0", "fe", "78", "cd", "5a", "f4"
            + "1f", "dd", "a8", "33", "88", "07", "c7", "31", "b1", "12", "10", "59", "27", "80", "ec", "5f"
            + "60", "51", "7f", "a9", "19", "b5", "4a", "0d", "2d", "e5", "7a", "9f", "93", "c9", "9c", "ef"
            + "a0", "e0", "3b", "4d", "ae", "2a", "f5", "b0", "c8", "eb", "bb", "3c", "83", "53", "99", "61"
            + "17", "2b", "04", "7e", "ba", "77", "d6", "26", "e1", "69", "14", "63", "55", "21", "0c", "7d"};

        for (int i = 0; i < 16; i++) {
            for (int j = 0; j < swap0.length; j++) {
                //if array element is equal to j
                if (text[i / 4][i % 4] == j) {
                    //swap with j element of sbox transformation
                    text[i / 4][i % 4] = Integer.parseInt(swap0[j], 16);
                }
            }
        }

        return text;
    }

    public static int[][] shiftrows(int[][] text) {
        int swap, swap1, swap2;

        swap = text[1][0];
        text[1][0] = text[1][1];
        text[1][1] = text[1][2];
        text[1][2] = text[1][3];
        text[1][3] = swap;

        swap = text[2][0];
        swap1 = text[2][1];
        text[2][0] = text[2][2];
        text[2][1] = text[2][3];
        text[2][2] = swap;
        text[2][3] = swap1;

        swap = text[3][0];
        swap1 = text[3][1];
        swap2 = text[3][2];
        text[3][0] = text[3][3];
        text[3][1] = swap;
        text[3][2] = swap1;
        text[3][3] = swap2;

        return text;
    }

    public static int[][] invshiftrows(int[][] text) {
        int swap, swap1, swap2;

        swap = text[1][0];
        swap1 = text[1][1];
        swap2 = text[1][2];
        text[1][0] = text[1][3];
        text[1][1] = swap;
        text[1][2] = swap1;
        text[1][3] = swap2;

        swap = text[2][0];
        swap1 = text[2][1];
        text[2][0] = text[2][2];
        text[2][1] = text[2][3];
        text[2][2] = swap;
        text[2][3] = swap1;

        swap = text[3][0];
        swap1 = text[3][1];
        swap2 = text[3][2];
        text[3][0] = swap1;
        text[3][1] = swap2;
        text[3][2] = text[3][3];
        text[3][3] = swap;

        return text;
    }

    public static int[][] mixcolumns(int[][] text, int[][] key, String poly) {
        int[][] temp = text;
        //int[][] mixcol = {{02, 03, 01, 01}, {01, 02, 03, 01}, {01, 01, 02, 03}, {03, 01, 01, 02}};

        text[0][0] = (temp[0][0] * key[0][0]) ^ (temp[0][1] * key[0][1]) ^ (temp[0][2] * key[0][2]) ^ (temp[0][3] * key[0][3]);
        text[1][0] = (temp[0][0] * key[1][0]) ^ (temp[0][1] * key[1][1]) ^ (temp[0][2] * key[1][2]) ^ (temp[0][3] * key[1][3]);
        text[2][0] = (temp[0][0] * key[2][0]) ^ (temp[0][1] * key[2][1]) ^ (temp[0][2] * key[2][2]) ^ (temp[0][3] * key[2][3]);
        text[3][0] = (temp[0][0] * key[3][0]) ^ (temp[0][1] * key[3][1]) ^ (temp[0][2] * key[3][2]) ^ (temp[0][3] * key[3][3]);
        text[0][1] = (temp[1][0] * key[0][0]) ^ (temp[1][1] * key[0][1]) ^ (temp[1][2] * key[0][2]) ^ (temp[1][3] * key[0][3]);
        text[1][1] = (temp[1][0] * key[1][0]) ^ (temp[1][1] * key[1][1]) ^ (temp[1][2] * key[1][2]) ^ (temp[1][3] * key[1][3]);
        text[2][1] = (temp[1][0] * key[2][0]) ^ (temp[1][1] * key[2][1]) ^ (temp[1][2] * key[2][2]) ^ (temp[1][3] * key[2][3]);
        text[3][1] = (temp[1][0] * key[3][0]) ^ (temp[1][1] * key[3][1]) ^ (temp[1][2] * key[3][2]) ^ (temp[1][3] * key[3][3]);
        text[0][2] = (temp[2][0] * key[0][0]) ^ (temp[2][1] * key[0][1]) ^ (temp[2][2] * key[0][2]) ^ (temp[2][3] * key[0][3]);
        text[1][2] = (temp[2][0] * key[1][0]) ^ (temp[2][1] * key[1][1]) ^ (temp[2][2] * key[1][2]) ^ (temp[2][3] * key[1][3]);
        text[2][2] = (temp[2][0] * key[2][0]) ^ (temp[2][1] * key[2][1]) ^ (temp[2][2] * key[2][2]) ^ (temp[2][3] * key[2][3]);
        text[3][2] = (temp[2][0] * key[3][0]) ^ (temp[2][1] * key[3][1]) ^ (temp[2][2] * key[3][2]) ^ (temp[2][3] * key[3][3]);
        text[0][3] = (temp[3][0] * key[0][0]) ^ (temp[3][1] * key[0][1]) ^ (temp[3][2] * key[0][2]) ^ (temp[3][3] * key[0][3]);
        text[1][3] = (temp[3][0] * key[1][0]) ^ (temp[3][1] * key[1][1]) ^ (temp[3][2] * key[1][2]) ^ (temp[3][3] * key[1][3]);
        text[2][3] = (temp[3][0] * key[2][0]) ^ (temp[3][1] * key[2][1]) ^ (temp[3][2] * key[2][2]) ^ (temp[3][3] * key[2][3]);
        text[3][3] = (temp[3][0] * key[3][0]) ^ (temp[3][1] * key[3][1]) ^ (temp[3][2] * key[3][2]) ^ (temp[3][3] * key[3][3]);

        for (int i = 0; i < 16; i++) {
           
            text[i / 4][i % 4] %= Integer.parseInt(poly, 2);
            text[i / 4][i % 4] %= 256;
        }

        return text;
    }

    public static int[][] invmixcolumns(int[][] text, int[][] key, String poly) {
        int[][] temp = text;
        /*int[][] invmixcol = {{Integer.parseInt("0e", 16), Integer.parseInt("0b", 16), Integer.parseInt("0d", 16), Integer.parseInt("09", 16)},
         {Integer.parseInt("09", 16), Integer.parseInt("0e", 16), Integer.parseInt("0b", 16), Integer.parseInt("0d", 16)},
         {Integer.parseInt("0d", 16), Integer.parseInt("09", 16), Integer.parseInt("0e", 16), Integer.parseInt("0b", 16)},
         {Integer.parseInt("0b", 16), Integer.parseInt("0d", 16), Integer.parseInt("09", 16), Integer.parseInt("0e", 16)}};*/

        text[0][0] = temp[0][0] * key[0][0] ^ temp[0][1] * key[0][1] ^ temp[0][2] * key[0][2] ^ temp[0][3] * key[0][3];
        text[1][0] = temp[0][0] * key[1][0] ^ temp[0][1] * key[1][1] ^ temp[0][2] * key[1][2] ^ temp[0][3] * key[1][3];
        text[2][0] = temp[0][0] * key[2][0] ^ temp[0][1] * key[2][1] ^ temp[0][2] * key[2][2] ^ temp[0][3] * key[2][3];
        text[3][0] = temp[0][0] * key[3][0] ^ temp[0][1] * key[3][1] ^ temp[0][2] * key[3][2] ^ temp[0][3] * key[3][3];
        text[0][1] = temp[1][0] * key[0][0] ^ temp[1][1] * key[0][1] ^ temp[1][2] * key[0][2] ^ temp[1][3] * key[0][3];
        text[1][1] = temp[1][0] * key[1][0] ^ temp[1][1] * key[1][1] ^ temp[1][2] * key[1][2] ^ temp[1][3] * key[1][3];
        text[2][1] = temp[1][0] * key[2][0] ^ temp[1][1] * key[2][1] ^ temp[1][2] * key[2][2] ^ temp[1][3] * key[2][3];
        text[3][1] = temp[1][0] * key[3][0] ^ temp[1][1] * key[3][1] ^ temp[1][2] * key[3][2] ^ temp[1][3] * key[3][3];
        text[0][2] = temp[2][0] * key[0][0] ^ temp[2][1] * key[0][1] ^ temp[2][2] * key[0][2] ^ temp[2][3] * key[0][3];
        text[1][2] = temp[2][0] * key[1][0] ^ temp[2][1] * key[1][1] ^ temp[2][2] * key[1][2] ^ temp[2][3] * key[1][3];
        text[2][2] = temp[2][0] * key[2][0] ^ temp[2][1] * key[2][1] ^ temp[2][2] * key[2][2] ^ temp[2][3] * key[2][3];
        text[3][2] = temp[2][0] * key[3][0] ^ temp[2][1] * key[3][1] ^ temp[2][2] * key[3][2] ^ temp[2][3] * key[3][3];
        text[0][3] = temp[3][0] * key[0][0] ^ temp[3][1] * key[0][1] ^ temp[3][2] * key[0][2] ^ temp[3][3] * key[0][3];
        text[1][3] = temp[3][0] * key[1][0] ^ temp[3][1] * key[1][1] ^ temp[3][2] * key[1][2] ^ temp[3][3] * key[1][3];
        text[2][3] = temp[3][0] * key[2][0] ^ temp[3][1] * key[2][1] ^ temp[3][2] * key[2][2] ^ temp[3][3] * key[2][3];
        text[3][3] = temp[3][0] * key[3][0] ^ temp[3][1] * key[3][1] ^ temp[3][2] * key[3][2] ^ temp[3][3] * key[3][3];

        for (int i = 0; i < 16; i++) {
            text[i / 4][i % 4] %= Integer.parseInt(poly, 2);
        }

        return text;
    }

    public static int[][] addroundkey(int[][] text, int[][] key) {
        for (int i = 0; i < 16; i++) {
            text[i / 4][i % 4] ^= key[i / 4][i % 4];
            text[i / 4][i % 4] %= 256;
        }
        return text;
    }

    public static int[][] keyexpansion(int[][] key, String poly, int num) {
        if (num == 0) {
            return key;
        } else {
            int mul = (int) Math.pow(2, num);
            int rcon = Integer.parseInt(poly,2) * mul;
            int[] word = {key[3][1], key[3][2], key[3][3], key[3][0]};
            String[] swap0 = {"63", "7c", "77", "7b", "f2", "6b", "6f", "c5", "30", "01", "67", "2b", "fe", "d7", "ab", "76"
                + "ca", "82", "c9", "7d", "fa", "59", "47", "f0", "ad", "d4", "a2", "af", "9c", "a4", "72", "c0"
                + "b7", "fd", "93", "26", "36", "3f", "f7", "cc", "34", "a5", "e5", "f1", "71", "d8", "31", "15"
                + "04", "c7", "23", "c3", "18", "96", "05", "9a", "07", "12", "80", "e2", "eb", "27", "b2", "75"
                + "09", "83", "2c", "1a", "1b", "6e", "5a", "a0", "52", "3b", "d6", "b3", "29", "e3", "2f", "84"
                + "53", "d1", "00", "ed", "20", "fc", "b1", "5b", "6a", "cb", "be", "39", "4a", "4c", "58", "cf"
                + "d0", "ef", "aa", "fb", "43", "4d", "33", "85", "45", "f9", "02", "7f", "50", "3c", "9f", "a8"
                + "51", "a3", "40", "8f", "92", "9d", "38", "f5", "bc", "b6", "da", "21", "10", "ff", "f3", "d2"
                + "cd", "0c", "13", "ec", "5f", "97", "44", "17", "c4", "a7", "7e", "3d", "64", "5d", "19", "73"
                + "60", "81", "4f", "dc", "22", "2a", "90", "88", "46", "ee", "b8", "14", "de", "5e", "0b", "db"
                + "e0", "32", "3a", "0a", "49", "06", "24", "5c", "c2", "d3", "ac", "62", "91", "95", "e4", "79"
                + "e7", "c8", "37", "6d", "8d", "d5", "4e", "a9", "6c", "56", "f4", "ea", "65", "7a", "ae", "08"
                + "ba", "78", "25", "2e", "1c", "a6", "b4", "c6", "e8", "dd", "74", "1f", "4b", "bd", "8b", "8a"
                + "70", "3e", "b5", "66", "48", "03", "f6", "0e", "61", "35", "57", "b9", "86", "c1", "1d", "93"
                + "e1", "f8", "98", "11", "69", "d9", "8e", "94", "9b", "1e", "87", "e9", "ce", "55", "28", "df"
                + "8c", "a1", "89", "0d", "bf", "e6", "42", "68", "41", "99", "2d", "0f", "b0", "54", "bb", "16"};

            for (int i = 0; i < 4; i++) {
                for (int j = 0; j < swap0.length; j++) {
                    //if array element is equal to j
                    if (word[i] == j) {
                        //swap with j element of sbox transformation
                        word[i] = Integer.parseInt(swap0[j], 16) ^ rcon;
                    }
                }
            }

            for (int i = 0; i < 4; i++) {
                key[i / 4][i % 4] ^= word[i % 4];
                key[i / 4][i % 4] %= 256;
            }

            for (int i = 4; i < 16; i++) {
                key[i / 4][i % 4] ^= key[(i / 4) - 1][(i % 4)];
                key[i / 4][i % 4] %= 256;
            }
            return key;
        }
    }

}

No comments:

Post a Comment

Thank you for reading.
Please share your thoughts.
Be blessed and enjoy life!