Translate To Preferred Language

Search ObiokusThoughts

Please Read Today's Featured Post

Alliteration Ere Zeitgeist

Actually ask archaic adult Broadband boy baked bad batch Cold case cant consistently catch Dawn developed dusk do-over Enact emerge...

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!