AES.java

package com.thealgorithms.ciphers;

import java.math.BigInteger;
import java.util.Scanner;

/**
 * This class is build to demonstrate the application of the AES-algorithm on a
 * single 128-Bit block of data.
 */
public final class AES {
    private AES() {
    }

    /**
     * Precalculated values for x to the power of 2 in Rijndaels galois field.
     * Used as 'RCON' during the key expansion.
     */
    private static final int[] RCON = {
        0x8d,
        0x01,
        0x02,
        0x04,
        0x08,
        0x10,
        0x20,
        0x40,
        0x80,
        0x1b,
        0x36,
        0x6c,
        0xd8,
        0xab,
        0x4d,
        0x9a,
        0x2f,
        0x5e,
        0xbc,
        0x63,
        0xc6,
        0x97,
        0x35,
        0x6a,
        0xd4,
        0xb3,
        0x7d,
        0xfa,
        0xef,
        0xc5,
        0x91,
        0x39,
        0x72,
        0xe4,
        0xd3,
        0xbd,
        0x61,
        0xc2,
        0x9f,
        0x25,
        0x4a,
        0x94,
        0x33,
        0x66,
        0xcc,
        0x83,
        0x1d,
        0x3a,
        0x74,
        0xe8,
        0xcb,
        0x8d,
        0x01,
        0x02,
        0x04,
        0x08,
        0x10,
        0x20,
        0x40,
        0x80,
        0x1b,
        0x36,
        0x6c,
        0xd8,
        0xab,
        0x4d,
        0x9a,
        0x2f,
        0x5e,
        0xbc,
        0x63,
        0xc6,
        0x97,
        0x35,
        0x6a,
        0xd4,
        0xb3,
        0x7d,
        0xfa,
        0xef,
        0xc5,
        0x91,
        0x39,
        0x72,
        0xe4,
        0xd3,
        0xbd,
        0x61,
        0xc2,
        0x9f,
        0x25,
        0x4a,
        0x94,
        0x33,
        0x66,
        0xcc,
        0x83,
        0x1d,
        0x3a,
        0x74,
        0xe8,
        0xcb,
        0x8d,
        0x01,
        0x02,
        0x04,
        0x08,
        0x10,
        0x20,
        0x40,
        0x80,
        0x1b,
        0x36,
        0x6c,
        0xd8,
        0xab,
        0x4d,
        0x9a,
        0x2f,
        0x5e,
        0xbc,
        0x63,
        0xc6,
        0x97,
        0x35,
        0x6a,
        0xd4,
        0xb3,
        0x7d,
        0xfa,
        0xef,
        0xc5,
        0x91,
        0x39,
        0x72,
        0xe4,
        0xd3,
        0xbd,
        0x61,
        0xc2,
        0x9f,
        0x25,
        0x4a,
        0x94,
        0x33,
        0x66,
        0xcc,
        0x83,
        0x1d,
        0x3a,
        0x74,
        0xe8,
        0xcb,
        0x8d,
        0x01,
        0x02,
        0x04,
        0x08,
        0x10,
        0x20,
        0x40,
        0x80,
        0x1b,
        0x36,
        0x6c,
        0xd8,
        0xab,
        0x4d,
        0x9a,
        0x2f,
        0x5e,
        0xbc,
        0x63,
        0xc6,
        0x97,
        0x35,
        0x6a,
        0xd4,
        0xb3,
        0x7d,
        0xfa,
        0xef,
        0xc5,
        0x91,
        0x39,
        0x72,
        0xe4,
        0xd3,
        0xbd,
        0x61,
        0xc2,
        0x9f,
        0x25,
        0x4a,
        0x94,
        0x33,
        0x66,
        0xcc,
        0x83,
        0x1d,
        0x3a,
        0x74,
        0xe8,
        0xcb,
        0x8d,
        0x01,
        0x02,
        0x04,
        0x08,
        0x10,
        0x20,
        0x40,
        0x80,
        0x1b,
        0x36,
        0x6c,
        0xd8,
        0xab,
        0x4d,
        0x9a,
        0x2f,
        0x5e,
        0xbc,
        0x63,
        0xc6,
        0x97,
        0x35,
        0x6a,
        0xd4,
        0xb3,
        0x7d,
        0xfa,
        0xef,
        0xc5,
        0x91,
        0x39,
        0x72,
        0xe4,
        0xd3,
        0xbd,
        0x61,
        0xc2,
        0x9f,
        0x25,
        0x4a,
        0x94,
        0x33,
        0x66,
        0xcc,
        0x83,
        0x1d,
        0x3a,
        0x74,
        0xe8,
        0xcb,
        0x8d,
    };

    /**
     * Rijndael S-box Substitution table used for encryption in the subBytes
     * step, as well as the key expansion.
     */
    private static final int[] SBOX = {
        0x63,
        0x7C,
        0x77,
        0x7B,
        0xF2,
        0x6B,
        0x6F,
        0xC5,
        0x30,
        0x01,
        0x67,
        0x2B,
        0xFE,
        0xD7,
        0xAB,
        0x76,
        0xCA,
        0x82,
        0xC9,
        0x7D,
        0xFA,
        0x59,
        0x47,
        0xF0,
        0xAD,
        0xD4,
        0xA2,
        0xAF,
        0x9C,
        0xA4,
        0x72,
        0xC0,
        0xB7,
        0xFD,
        0x93,
        0x26,
        0x36,
        0x3F,
        0xF7,
        0xCC,
        0x34,
        0xA5,
        0xE5,
        0xF1,
        0x71,
        0xD8,
        0x31,
        0x15,
        0x04,
        0xC7,
        0x23,
        0xC3,
        0x18,
        0x96,
        0x05,
        0x9A,
        0x07,
        0x12,
        0x80,
        0xE2,
        0xEB,
        0x27,
        0xB2,
        0x75,
        0x09,
        0x83,
        0x2C,
        0x1A,
        0x1B,
        0x6E,
        0x5A,
        0xA0,
        0x52,
        0x3B,
        0xD6,
        0xB3,
        0x29,
        0xE3,
        0x2F,
        0x84,
        0x53,
        0xD1,
        0x00,
        0xED,
        0x20,
        0xFC,
        0xB1,
        0x5B,
        0x6A,
        0xCB,
        0xBE,
        0x39,
        0x4A,
        0x4C,
        0x58,
        0xCF,
        0xD0,
        0xEF,
        0xAA,
        0xFB,
        0x43,
        0x4D,
        0x33,
        0x85,
        0x45,
        0xF9,
        0x02,
        0x7F,
        0x50,
        0x3C,
        0x9F,
        0xA8,
        0x51,
        0xA3,
        0x40,
        0x8F,
        0x92,
        0x9D,
        0x38,
        0xF5,
        0xBC,
        0xB6,
        0xDA,
        0x21,
        0x10,
        0xFF,
        0xF3,
        0xD2,
        0xCD,
        0x0C,
        0x13,
        0xEC,
        0x5F,
        0x97,
        0x44,
        0x17,
        0xC4,
        0xA7,
        0x7E,
        0x3D,
        0x64,
        0x5D,
        0x19,
        0x73,
        0x60,
        0x81,
        0x4F,
        0xDC,
        0x22,
        0x2A,
        0x90,
        0x88,
        0x46,
        0xEE,
        0xB8,
        0x14,
        0xDE,
        0x5E,
        0x0B,
        0xDB,
        0xE0,
        0x32,
        0x3A,
        0x0A,
        0x49,
        0x06,
        0x24,
        0x5C,
        0xC2,
        0xD3,
        0xAC,
        0x62,
        0x91,
        0x95,
        0xE4,
        0x79,
        0xE7,
        0xC8,
        0x37,
        0x6D,
        0x8D,
        0xD5,
        0x4E,
        0xA9,
        0x6C,
        0x56,
        0xF4,
        0xEA,
        0x65,
        0x7A,
        0xAE,
        0x08,
        0xBA,
        0x78,
        0x25,
        0x2E,
        0x1C,
        0xA6,
        0xB4,
        0xC6,
        0xE8,
        0xDD,
        0x74,
        0x1F,
        0x4B,
        0xBD,
        0x8B,
        0x8A,
        0x70,
        0x3E,
        0xB5,
        0x66,
        0x48,
        0x03,
        0xF6,
        0x0E,
        0x61,
        0x35,
        0x57,
        0xB9,
        0x86,
        0xC1,
        0x1D,
        0x9E,
        0xE1,
        0xF8,
        0x98,
        0x11,
        0x69,
        0xD9,
        0x8E,
        0x94,
        0x9B,
        0x1E,
        0x87,
        0xE9,
        0xCE,
        0x55,
        0x28,
        0xDF,
        0x8C,
        0xA1,
        0x89,
        0x0D,
        0xBF,
        0xE6,
        0x42,
        0x68,
        0x41,
        0x99,
        0x2D,
        0x0F,
        0xB0,
        0x54,
        0xBB,
        0x16,
    };

    /**
     * Inverse Rijndael S-box Substitution table used for decryption in the
     * subBytesDec step.
     */
    private static final int[] INVERSE_SBOX = {
        0x52,
        0x09,
        0x6A,
        0xD5,
        0x30,
        0x36,
        0xA5,
        0x38,
        0xBF,
        0x40,
        0xA3,
        0x9E,
        0x81,
        0xF3,
        0xD7,
        0xFB,
        0x7C,
        0xE3,
        0x39,
        0x82,
        0x9B,
        0x2F,
        0xFF,
        0x87,
        0x34,
        0x8E,
        0x43,
        0x44,
        0xC4,
        0xDE,
        0xE9,
        0xCB,
        0x54,
        0x7B,
        0x94,
        0x32,
        0xA6,
        0xC2,
        0x23,
        0x3D,
        0xEE,
        0x4C,
        0x95,
        0x0B,
        0x42,
        0xFA,
        0xC3,
        0x4E,
        0x08,
        0x2E,
        0xA1,
        0x66,
        0x28,
        0xD9,
        0x24,
        0xB2,
        0x76,
        0x5B,
        0xA2,
        0x49,
        0x6D,
        0x8B,
        0xD1,
        0x25,
        0x72,
        0xF8,
        0xF6,
        0x64,
        0x86,
        0x68,
        0x98,
        0x16,
        0xD4,
        0xA4,
        0x5C,
        0xCC,
        0x5D,
        0x65,
        0xB6,
        0x92,
        0x6C,
        0x70,
        0x48,
        0x50,
        0xFD,
        0xED,
        0xB9,
        0xDA,
        0x5E,
        0x15,
        0x46,
        0x57,
        0xA7,
        0x8D,
        0x9D,
        0x84,
        0x90,
        0xD8,
        0xAB,
        0x00,
        0x8C,
        0xBC,
        0xD3,
        0x0A,
        0xF7,
        0xE4,
        0x58,
        0x05,
        0xB8,
        0xB3,
        0x45,
        0x06,
        0xD0,
        0x2C,
        0x1E,
        0x8F,
        0xCA,
        0x3F,
        0x0F,
        0x02,
        0xC1,
        0xAF,
        0xBD,
        0x03,
        0x01,
        0x13,
        0x8A,
        0x6B,
        0x3A,
        0x91,
        0x11,
        0x41,
        0x4F,
        0x67,
        0xDC,
        0xEA,
        0x97,
        0xF2,
        0xCF,
        0xCE,
        0xF0,
        0xB4,
        0xE6,
        0x73,
        0x96,
        0xAC,
        0x74,
        0x22,
        0xE7,
        0xAD,
        0x35,
        0x85,
        0xE2,
        0xF9,
        0x37,
        0xE8,
        0x1C,
        0x75,
        0xDF,
        0x6E,
        0x47,
        0xF1,
        0x1A,
        0x71,
        0x1D,
        0x29,
        0xC5,
        0x89,
        0x6F,
        0xB7,
        0x62,
        0x0E,
        0xAA,
        0x18,
        0xBE,
        0x1B,
        0xFC,
        0x56,
        0x3E,
        0x4B,
        0xC6,
        0xD2,
        0x79,
        0x20,
        0x9A,
        0xDB,
        0xC0,
        0xFE,
        0x78,
        0xCD,
        0x5A,
        0xF4,
        0x1F,
        0xDD,
        0xA8,
        0x33,
        0x88,
        0x07,
        0xC7,
        0x31,
        0xB1,
        0x12,
        0x10,
        0x59,
        0x27,
        0x80,
        0xEC,
        0x5F,
        0x60,
        0x51,
        0x7F,
        0xA9,
        0x19,
        0xB5,
        0x4A,
        0x0D,
        0x2D,
        0xE5,
        0x7A,
        0x9F,
        0x93,
        0xC9,
        0x9C,
        0xEF,
        0xA0,
        0xE0,
        0x3B,
        0x4D,
        0xAE,
        0x2A,
        0xF5,
        0xB0,
        0xC8,
        0xEB,
        0xBB,
        0x3C,
        0x83,
        0x53,
        0x99,
        0x61,
        0x17,
        0x2B,
        0x04,
        0x7E,
        0xBA,
        0x77,
        0xD6,
        0x26,
        0xE1,
        0x69,
        0x14,
        0x63,
        0x55,
        0x21,
        0x0C,
        0x7D,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 2 used in
     * the MixColums step during encryption.
     */
    private static final int[] MULT2 = {
        0x00,
        0x02,
        0x04,
        0x06,
        0x08,
        0x0a,
        0x0c,
        0x0e,
        0x10,
        0x12,
        0x14,
        0x16,
        0x18,
        0x1a,
        0x1c,
        0x1e,
        0x20,
        0x22,
        0x24,
        0x26,
        0x28,
        0x2a,
        0x2c,
        0x2e,
        0x30,
        0x32,
        0x34,
        0x36,
        0x38,
        0x3a,
        0x3c,
        0x3e,
        0x40,
        0x42,
        0x44,
        0x46,
        0x48,
        0x4a,
        0x4c,
        0x4e,
        0x50,
        0x52,
        0x54,
        0x56,
        0x58,
        0x5a,
        0x5c,
        0x5e,
        0x60,
        0x62,
        0x64,
        0x66,
        0x68,
        0x6a,
        0x6c,
        0x6e,
        0x70,
        0x72,
        0x74,
        0x76,
        0x78,
        0x7a,
        0x7c,
        0x7e,
        0x80,
        0x82,
        0x84,
        0x86,
        0x88,
        0x8a,
        0x8c,
        0x8e,
        0x90,
        0x92,
        0x94,
        0x96,
        0x98,
        0x9a,
        0x9c,
        0x9e,
        0xa0,
        0xa2,
        0xa4,
        0xa6,
        0xa8,
        0xaa,
        0xac,
        0xae,
        0xb0,
        0xb2,
        0xb4,
        0xb6,
        0xb8,
        0xba,
        0xbc,
        0xbe,
        0xc0,
        0xc2,
        0xc4,
        0xc6,
        0xc8,
        0xca,
        0xcc,
        0xce,
        0xd0,
        0xd2,
        0xd4,
        0xd6,
        0xd8,
        0xda,
        0xdc,
        0xde,
        0xe0,
        0xe2,
        0xe4,
        0xe6,
        0xe8,
        0xea,
        0xec,
        0xee,
        0xf0,
        0xf2,
        0xf4,
        0xf6,
        0xf8,
        0xfa,
        0xfc,
        0xfe,
        0x1b,
        0x19,
        0x1f,
        0x1d,
        0x13,
        0x11,
        0x17,
        0x15,
        0x0b,
        0x09,
        0x0f,
        0x0d,
        0x03,
        0x01,
        0x07,
        0x05,
        0x3b,
        0x39,
        0x3f,
        0x3d,
        0x33,
        0x31,
        0x37,
        0x35,
        0x2b,
        0x29,
        0x2f,
        0x2d,
        0x23,
        0x21,
        0x27,
        0x25,
        0x5b,
        0x59,
        0x5f,
        0x5d,
        0x53,
        0x51,
        0x57,
        0x55,
        0x4b,
        0x49,
        0x4f,
        0x4d,
        0x43,
        0x41,
        0x47,
        0x45,
        0x7b,
        0x79,
        0x7f,
        0x7d,
        0x73,
        0x71,
        0x77,
        0x75,
        0x6b,
        0x69,
        0x6f,
        0x6d,
        0x63,
        0x61,
        0x67,
        0x65,
        0x9b,
        0x99,
        0x9f,
        0x9d,
        0x93,
        0x91,
        0x97,
        0x95,
        0x8b,
        0x89,
        0x8f,
        0x8d,
        0x83,
        0x81,
        0x87,
        0x85,
        0xbb,
        0xb9,
        0xbf,
        0xbd,
        0xb3,
        0xb1,
        0xb7,
        0xb5,
        0xab,
        0xa9,
        0xaf,
        0xad,
        0xa3,
        0xa1,
        0xa7,
        0xa5,
        0xdb,
        0xd9,
        0xdf,
        0xdd,
        0xd3,
        0xd1,
        0xd7,
        0xd5,
        0xcb,
        0xc9,
        0xcf,
        0xcd,
        0xc3,
        0xc1,
        0xc7,
        0xc5,
        0xfb,
        0xf9,
        0xff,
        0xfd,
        0xf3,
        0xf1,
        0xf7,
        0xf5,
        0xeb,
        0xe9,
        0xef,
        0xed,
        0xe3,
        0xe1,
        0xe7,
        0xe5,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 3 used in
     * the MixColums step during encryption.
     */
    private static final int[] MULT3 = {
        0x00,
        0x03,
        0x06,
        0x05,
        0x0c,
        0x0f,
        0x0a,
        0x09,
        0x18,
        0x1b,
        0x1e,
        0x1d,
        0x14,
        0x17,
        0x12,
        0x11,
        0x30,
        0x33,
        0x36,
        0x35,
        0x3c,
        0x3f,
        0x3a,
        0x39,
        0x28,
        0x2b,
        0x2e,
        0x2d,
        0x24,
        0x27,
        0x22,
        0x21,
        0x60,
        0x63,
        0x66,
        0x65,
        0x6c,
        0x6f,
        0x6a,
        0x69,
        0x78,
        0x7b,
        0x7e,
        0x7d,
        0x74,
        0x77,
        0x72,
        0x71,
        0x50,
        0x53,
        0x56,
        0x55,
        0x5c,
        0x5f,
        0x5a,
        0x59,
        0x48,
        0x4b,
        0x4e,
        0x4d,
        0x44,
        0x47,
        0x42,
        0x41,
        0xc0,
        0xc3,
        0xc6,
        0xc5,
        0xcc,
        0xcf,
        0xca,
        0xc9,
        0xd8,
        0xdb,
        0xde,
        0xdd,
        0xd4,
        0xd7,
        0xd2,
        0xd1,
        0xf0,
        0xf3,
        0xf6,
        0xf5,
        0xfc,
        0xff,
        0xfa,
        0xf9,
        0xe8,
        0xeb,
        0xee,
        0xed,
        0xe4,
        0xe7,
        0xe2,
        0xe1,
        0xa0,
        0xa3,
        0xa6,
        0xa5,
        0xac,
        0xaf,
        0xaa,
        0xa9,
        0xb8,
        0xbb,
        0xbe,
        0xbd,
        0xb4,
        0xb7,
        0xb2,
        0xb1,
        0x90,
        0x93,
        0x96,
        0x95,
        0x9c,
        0x9f,
        0x9a,
        0x99,
        0x88,
        0x8b,
        0x8e,
        0x8d,
        0x84,
        0x87,
        0x82,
        0x81,
        0x9b,
        0x98,
        0x9d,
        0x9e,
        0x97,
        0x94,
        0x91,
        0x92,
        0x83,
        0x80,
        0x85,
        0x86,
        0x8f,
        0x8c,
        0x89,
        0x8a,
        0xab,
        0xa8,
        0xad,
        0xae,
        0xa7,
        0xa4,
        0xa1,
        0xa2,
        0xb3,
        0xb0,
        0xb5,
        0xb6,
        0xbf,
        0xbc,
        0xb9,
        0xba,
        0xfb,
        0xf8,
        0xfd,
        0xfe,
        0xf7,
        0xf4,
        0xf1,
        0xf2,
        0xe3,
        0xe0,
        0xe5,
        0xe6,
        0xef,
        0xec,
        0xe9,
        0xea,
        0xcb,
        0xc8,
        0xcd,
        0xce,
        0xc7,
        0xc4,
        0xc1,
        0xc2,
        0xd3,
        0xd0,
        0xd5,
        0xd6,
        0xdf,
        0xdc,
        0xd9,
        0xda,
        0x5b,
        0x58,
        0x5d,
        0x5e,
        0x57,
        0x54,
        0x51,
        0x52,
        0x43,
        0x40,
        0x45,
        0x46,
        0x4f,
        0x4c,
        0x49,
        0x4a,
        0x6b,
        0x68,
        0x6d,
        0x6e,
        0x67,
        0x64,
        0x61,
        0x62,
        0x73,
        0x70,
        0x75,
        0x76,
        0x7f,
        0x7c,
        0x79,
        0x7a,
        0x3b,
        0x38,
        0x3d,
        0x3e,
        0x37,
        0x34,
        0x31,
        0x32,
        0x23,
        0x20,
        0x25,
        0x26,
        0x2f,
        0x2c,
        0x29,
        0x2a,
        0x0b,
        0x08,
        0x0d,
        0x0e,
        0x07,
        0x04,
        0x01,
        0x02,
        0x13,
        0x10,
        0x15,
        0x16,
        0x1f,
        0x1c,
        0x19,
        0x1a,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 9 used in
     * the MixColums step during decryption.
     */
    private static final int[] MULT9 = {
        0x00,
        0x09,
        0x12,
        0x1b,
        0x24,
        0x2d,
        0x36,
        0x3f,
        0x48,
        0x41,
        0x5a,
        0x53,
        0x6c,
        0x65,
        0x7e,
        0x77,
        0x90,
        0x99,
        0x82,
        0x8b,
        0xb4,
        0xbd,
        0xa6,
        0xaf,
        0xd8,
        0xd1,
        0xca,
        0xc3,
        0xfc,
        0xf5,
        0xee,
        0xe7,
        0x3b,
        0x32,
        0x29,
        0x20,
        0x1f,
        0x16,
        0x0d,
        0x04,
        0x73,
        0x7a,
        0x61,
        0x68,
        0x57,
        0x5e,
        0x45,
        0x4c,
        0xab,
        0xa2,
        0xb9,
        0xb0,
        0x8f,
        0x86,
        0x9d,
        0x94,
        0xe3,
        0xea,
        0xf1,
        0xf8,
        0xc7,
        0xce,
        0xd5,
        0xdc,
        0x76,
        0x7f,
        0x64,
        0x6d,
        0x52,
        0x5b,
        0x40,
        0x49,
        0x3e,
        0x37,
        0x2c,
        0x25,
        0x1a,
        0x13,
        0x08,
        0x01,
        0xe6,
        0xef,
        0xf4,
        0xfd,
        0xc2,
        0xcb,
        0xd0,
        0xd9,
        0xae,
        0xa7,
        0xbc,
        0xb5,
        0x8a,
        0x83,
        0x98,
        0x91,
        0x4d,
        0x44,
        0x5f,
        0x56,
        0x69,
        0x60,
        0x7b,
        0x72,
        0x05,
        0x0c,
        0x17,
        0x1e,
        0x21,
        0x28,
        0x33,
        0x3a,
        0xdd,
        0xd4,
        0xcf,
        0xc6,
        0xf9,
        0xf0,
        0xeb,
        0xe2,
        0x95,
        0x9c,
        0x87,
        0x8e,
        0xb1,
        0xb8,
        0xa3,
        0xaa,
        0xec,
        0xe5,
        0xfe,
        0xf7,
        0xc8,
        0xc1,
        0xda,
        0xd3,
        0xa4,
        0xad,
        0xb6,
        0xbf,
        0x80,
        0x89,
        0x92,
        0x9b,
        0x7c,
        0x75,
        0x6e,
        0x67,
        0x58,
        0x51,
        0x4a,
        0x43,
        0x34,
        0x3d,
        0x26,
        0x2f,
        0x10,
        0x19,
        0x02,
        0x0b,
        0xd7,
        0xde,
        0xc5,
        0xcc,
        0xf3,
        0xfa,
        0xe1,
        0xe8,
        0x9f,
        0x96,
        0x8d,
        0x84,
        0xbb,
        0xb2,
        0xa9,
        0xa0,
        0x47,
        0x4e,
        0x55,
        0x5c,
        0x63,
        0x6a,
        0x71,
        0x78,
        0x0f,
        0x06,
        0x1d,
        0x14,
        0x2b,
        0x22,
        0x39,
        0x30,
        0x9a,
        0x93,
        0x88,
        0x81,
        0xbe,
        0xb7,
        0xac,
        0xa5,
        0xd2,
        0xdb,
        0xc0,
        0xc9,
        0xf6,
        0xff,
        0xe4,
        0xed,
        0x0a,
        0x03,
        0x18,
        0x11,
        0x2e,
        0x27,
        0x3c,
        0x35,
        0x42,
        0x4b,
        0x50,
        0x59,
        0x66,
        0x6f,
        0x74,
        0x7d,
        0xa1,
        0xa8,
        0xb3,
        0xba,
        0x85,
        0x8c,
        0x97,
        0x9e,
        0xe9,
        0xe0,
        0xfb,
        0xf2,
        0xcd,
        0xc4,
        0xdf,
        0xd6,
        0x31,
        0x38,
        0x23,
        0x2a,
        0x15,
        0x1c,
        0x07,
        0x0e,
        0x79,
        0x70,
        0x6b,
        0x62,
        0x5d,
        0x54,
        0x4f,
        0x46,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 11 used in
     * the MixColums step during decryption.
     */
    private static final int[] MULT11 = {
        0x00,
        0x0b,
        0x16,
        0x1d,
        0x2c,
        0x27,
        0x3a,
        0x31,
        0x58,
        0x53,
        0x4e,
        0x45,
        0x74,
        0x7f,
        0x62,
        0x69,
        0xb0,
        0xbb,
        0xa6,
        0xad,
        0x9c,
        0x97,
        0x8a,
        0x81,
        0xe8,
        0xe3,
        0xfe,
        0xf5,
        0xc4,
        0xcf,
        0xd2,
        0xd9,
        0x7b,
        0x70,
        0x6d,
        0x66,
        0x57,
        0x5c,
        0x41,
        0x4a,
        0x23,
        0x28,
        0x35,
        0x3e,
        0x0f,
        0x04,
        0x19,
        0x12,
        0xcb,
        0xc0,
        0xdd,
        0xd6,
        0xe7,
        0xec,
        0xf1,
        0xfa,
        0x93,
        0x98,
        0x85,
        0x8e,
        0xbf,
        0xb4,
        0xa9,
        0xa2,
        0xf6,
        0xfd,
        0xe0,
        0xeb,
        0xda,
        0xd1,
        0xcc,
        0xc7,
        0xae,
        0xa5,
        0xb8,
        0xb3,
        0x82,
        0x89,
        0x94,
        0x9f,
        0x46,
        0x4d,
        0x50,
        0x5b,
        0x6a,
        0x61,
        0x7c,
        0x77,
        0x1e,
        0x15,
        0x08,
        0x03,
        0x32,
        0x39,
        0x24,
        0x2f,
        0x8d,
        0x86,
        0x9b,
        0x90,
        0xa1,
        0xaa,
        0xb7,
        0xbc,
        0xd5,
        0xde,
        0xc3,
        0xc8,
        0xf9,
        0xf2,
        0xef,
        0xe4,
        0x3d,
        0x36,
        0x2b,
        0x20,
        0x11,
        0x1a,
        0x07,
        0x0c,
        0x65,
        0x6e,
        0x73,
        0x78,
        0x49,
        0x42,
        0x5f,
        0x54,
        0xf7,
        0xfc,
        0xe1,
        0xea,
        0xdb,
        0xd0,
        0xcd,
        0xc6,
        0xaf,
        0xa4,
        0xb9,
        0xb2,
        0x83,
        0x88,
        0x95,
        0x9e,
        0x47,
        0x4c,
        0x51,
        0x5a,
        0x6b,
        0x60,
        0x7d,
        0x76,
        0x1f,
        0x14,
        0x09,
        0x02,
        0x33,
        0x38,
        0x25,
        0x2e,
        0x8c,
        0x87,
        0x9a,
        0x91,
        0xa0,
        0xab,
        0xb6,
        0xbd,
        0xd4,
        0xdf,
        0xc2,
        0xc9,
        0xf8,
        0xf3,
        0xee,
        0xe5,
        0x3c,
        0x37,
        0x2a,
        0x21,
        0x10,
        0x1b,
        0x06,
        0x0d,
        0x64,
        0x6f,
        0x72,
        0x79,
        0x48,
        0x43,
        0x5e,
        0x55,
        0x01,
        0x0a,
        0x17,
        0x1c,
        0x2d,
        0x26,
        0x3b,
        0x30,
        0x59,
        0x52,
        0x4f,
        0x44,
        0x75,
        0x7e,
        0x63,
        0x68,
        0xb1,
        0xba,
        0xa7,
        0xac,
        0x9d,
        0x96,
        0x8b,
        0x80,
        0xe9,
        0xe2,
        0xff,
        0xf4,
        0xc5,
        0xce,
        0xd3,
        0xd8,
        0x7a,
        0x71,
        0x6c,
        0x67,
        0x56,
        0x5d,
        0x40,
        0x4b,
        0x22,
        0x29,
        0x34,
        0x3f,
        0x0e,
        0x05,
        0x18,
        0x13,
        0xca,
        0xc1,
        0xdc,
        0xd7,
        0xe6,
        0xed,
        0xf0,
        0xfb,
        0x92,
        0x99,
        0x84,
        0x8f,
        0xbe,
        0xb5,
        0xa8,
        0xa3,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 13 used in
     * the MixColums step during decryption.
     */
    private static final int[] MULT13 = {
        0x00,
        0x0d,
        0x1a,
        0x17,
        0x34,
        0x39,
        0x2e,
        0x23,
        0x68,
        0x65,
        0x72,
        0x7f,
        0x5c,
        0x51,
        0x46,
        0x4b,
        0xd0,
        0xdd,
        0xca,
        0xc7,
        0xe4,
        0xe9,
        0xfe,
        0xf3,
        0xb8,
        0xb5,
        0xa2,
        0xaf,
        0x8c,
        0x81,
        0x96,
        0x9b,
        0xbb,
        0xb6,
        0xa1,
        0xac,
        0x8f,
        0x82,
        0x95,
        0x98,
        0xd3,
        0xde,
        0xc9,
        0xc4,
        0xe7,
        0xea,
        0xfd,
        0xf0,
        0x6b,
        0x66,
        0x71,
        0x7c,
        0x5f,
        0x52,
        0x45,
        0x48,
        0x03,
        0x0e,
        0x19,
        0x14,
        0x37,
        0x3a,
        0x2d,
        0x20,
        0x6d,
        0x60,
        0x77,
        0x7a,
        0x59,
        0x54,
        0x43,
        0x4e,
        0x05,
        0x08,
        0x1f,
        0x12,
        0x31,
        0x3c,
        0x2b,
        0x26,
        0xbd,
        0xb0,
        0xa7,
        0xaa,
        0x89,
        0x84,
        0x93,
        0x9e,
        0xd5,
        0xd8,
        0xcf,
        0xc2,
        0xe1,
        0xec,
        0xfb,
        0xf6,
        0xd6,
        0xdb,
        0xcc,
        0xc1,
        0xe2,
        0xef,
        0xf8,
        0xf5,
        0xbe,
        0xb3,
        0xa4,
        0xa9,
        0x8a,
        0x87,
        0x90,
        0x9d,
        0x06,
        0x0b,
        0x1c,
        0x11,
        0x32,
        0x3f,
        0x28,
        0x25,
        0x6e,
        0x63,
        0x74,
        0x79,
        0x5a,
        0x57,
        0x40,
        0x4d,
        0xda,
        0xd7,
        0xc0,
        0xcd,
        0xee,
        0xe3,
        0xf4,
        0xf9,
        0xb2,
        0xbf,
        0xa8,
        0xa5,
        0x86,
        0x8b,
        0x9c,
        0x91,
        0x0a,
        0x07,
        0x10,
        0x1d,
        0x3e,
        0x33,
        0x24,
        0x29,
        0x62,
        0x6f,
        0x78,
        0x75,
        0x56,
        0x5b,
        0x4c,
        0x41,
        0x61,
        0x6c,
        0x7b,
        0x76,
        0x55,
        0x58,
        0x4f,
        0x42,
        0x09,
        0x04,
        0x13,
        0x1e,
        0x3d,
        0x30,
        0x27,
        0x2a,
        0xb1,
        0xbc,
        0xab,
        0xa6,
        0x85,
        0x88,
        0x9f,
        0x92,
        0xd9,
        0xd4,
        0xc3,
        0xce,
        0xed,
        0xe0,
        0xf7,
        0xfa,
        0xb7,
        0xba,
        0xad,
        0xa0,
        0x83,
        0x8e,
        0x99,
        0x94,
        0xdf,
        0xd2,
        0xc5,
        0xc8,
        0xeb,
        0xe6,
        0xf1,
        0xfc,
        0x67,
        0x6a,
        0x7d,
        0x70,
        0x53,
        0x5e,
        0x49,
        0x44,
        0x0f,
        0x02,
        0x15,
        0x18,
        0x3b,
        0x36,
        0x21,
        0x2c,
        0x0c,
        0x01,
        0x16,
        0x1b,
        0x38,
        0x35,
        0x22,
        0x2f,
        0x64,
        0x69,
        0x7e,
        0x73,
        0x50,
        0x5d,
        0x4a,
        0x47,
        0xdc,
        0xd1,
        0xc6,
        0xcb,
        0xe8,
        0xe5,
        0xf2,
        0xff,
        0xb4,
        0xb9,
        0xae,
        0xa3,
        0x80,
        0x8d,
        0x9a,
        0x97,
    };

    /**
     * Precalculated lookup table for galois field multiplication by 14 used in
     * the MixColums step during decryption.
     */
    private static final int[] MULT14 = {
        0x00,
        0x0e,
        0x1c,
        0x12,
        0x38,
        0x36,
        0x24,
        0x2a,
        0x70,
        0x7e,
        0x6c,
        0x62,
        0x48,
        0x46,
        0x54,
        0x5a,
        0xe0,
        0xee,
        0xfc,
        0xf2,
        0xd8,
        0xd6,
        0xc4,
        0xca,
        0x90,
        0x9e,
        0x8c,
        0x82,
        0xa8,
        0xa6,
        0xb4,
        0xba,
        0xdb,
        0xd5,
        0xc7,
        0xc9,
        0xe3,
        0xed,
        0xff,
        0xf1,
        0xab,
        0xa5,
        0xb7,
        0xb9,
        0x93,
        0x9d,
        0x8f,
        0x81,
        0x3b,
        0x35,
        0x27,
        0x29,
        0x03,
        0x0d,
        0x1f,
        0x11,
        0x4b,
        0x45,
        0x57,
        0x59,
        0x73,
        0x7d,
        0x6f,
        0x61,
        0xad,
        0xa3,
        0xb1,
        0xbf,
        0x95,
        0x9b,
        0x89,
        0x87,
        0xdd,
        0xd3,
        0xc1,
        0xcf,
        0xe5,
        0xeb,
        0xf9,
        0xf7,
        0x4d,
        0x43,
        0x51,
        0x5f,
        0x75,
        0x7b,
        0x69,
        0x67,
        0x3d,
        0x33,
        0x21,
        0x2f,
        0x05,
        0x0b,
        0x19,
        0x17,
        0x76,
        0x78,
        0x6a,
        0x64,
        0x4e,
        0x40,
        0x52,
        0x5c,
        0x06,
        0x08,
        0x1a,
        0x14,
        0x3e,
        0x30,
        0x22,
        0x2c,
        0x96,
        0x98,
        0x8a,
        0x84,
        0xae,
        0xa0,
        0xb2,
        0xbc,
        0xe6,
        0xe8,
        0xfa,
        0xf4,
        0xde,
        0xd0,
        0xc2,
        0xcc,
        0x41,
        0x4f,
        0x5d,
        0x53,
        0x79,
        0x77,
        0x65,
        0x6b,
        0x31,
        0x3f,
        0x2d,
        0x23,
        0x09,
        0x07,
        0x15,
        0x1b,
        0xa1,
        0xaf,
        0xbd,
        0xb3,
        0x99,
        0x97,
        0x85,
        0x8b,
        0xd1,
        0xdf,
        0xcd,
        0xc3,
        0xe9,
        0xe7,
        0xf5,
        0xfb,
        0x9a,
        0x94,
        0x86,
        0x88,
        0xa2,
        0xac,
        0xbe,
        0xb0,
        0xea,
        0xe4,
        0xf6,
        0xf8,
        0xd2,
        0xdc,
        0xce,
        0xc0,
        0x7a,
        0x74,
        0x66,
        0x68,
        0x42,
        0x4c,
        0x5e,
        0x50,
        0x0a,
        0x04,
        0x16,
        0x18,
        0x32,
        0x3c,
        0x2e,
        0x20,
        0xec,
        0xe2,
        0xf0,
        0xfe,
        0xd4,
        0xda,
        0xc8,
        0xc6,
        0x9c,
        0x92,
        0x80,
        0x8e,
        0xa4,
        0xaa,
        0xb8,
        0xb6,
        0x0c,
        0x02,
        0x10,
        0x1e,
        0x34,
        0x3a,
        0x28,
        0x26,
        0x7c,
        0x72,
        0x60,
        0x6e,
        0x44,
        0x4a,
        0x58,
        0x56,
        0x37,
        0x39,
        0x2b,
        0x25,
        0x0f,
        0x01,
        0x13,
        0x1d,
        0x47,
        0x49,
        0x5b,
        0x55,
        0x7f,
        0x71,
        0x63,
        0x6d,
        0xd7,
        0xd9,
        0xcb,
        0xc5,
        0xef,
        0xe1,
        0xf3,
        0xfd,
        0xa7,
        0xa9,
        0xbb,
        0xb5,
        0x9f,
        0x91,
        0x83,
        0x8d,
    };

    /**
     * Subroutine of the Rijndael key expansion.
     */
    public static BigInteger scheduleCore(BigInteger t, int rconCounter) {
        StringBuilder rBytes = new StringBuilder(t.toString(16));

        // Add zero padding
        while (rBytes.length() < 8) {
            rBytes.insert(0, "0");
        }

        // rotate the first 16 bits to the back
        String rotatingBytes = rBytes.substring(0, 2);
        String fixedBytes = rBytes.substring(2);

        rBytes = new StringBuilder(fixedBytes + rotatingBytes);

        // apply S-Box to all 8-Bit Substrings
        for (int i = 0; i < 4; i++) {
            StringBuilder currentByteBits = new StringBuilder(rBytes.substring(i * 2, (i + 1) * 2));

            int currentByte = Integer.parseInt(currentByteBits.toString(), 16);
            currentByte = SBOX[currentByte];

            // add the current RCON value to the first byte
            if (i == 0) {
                currentByte = currentByte ^ RCON[rconCounter];
            }

            currentByteBits = new StringBuilder(Integer.toHexString(currentByte));

            // Add zero padding
            while (currentByteBits.length() < 2) {
                currentByteBits.insert(0, '0');
            }

            // replace bytes in original string
            rBytes = new StringBuilder(rBytes.substring(0, i * 2) + currentByteBits + rBytes.substring((i + 1) * 2));
        }

        // t = new BigInteger(rBytes, 16);
        // return t;
        return new BigInteger(rBytes.toString(), 16);
    }

    /**
     * Returns an array of 10 + 1 round keys that are calculated by using
     * Rijndael key schedule
     *
     * @return array of 10 + 1 round keys
     */
    public static BigInteger[] keyExpansion(BigInteger initialKey) {
        BigInteger[] roundKeys = {
            initialKey,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
            BigInteger.ZERO,
        };

        // initialize rcon iteration
        int rconCounter = 1;

        for (int i = 1; i < 11; i++) {
            // get the previous 32 bits the key
            BigInteger t = roundKeys[i - 1].remainder(new BigInteger("100000000", 16));

            // split previous key into 8-bit segments
            BigInteger[] prevKey = {
                roundKeys[i - 1].remainder(new BigInteger("100000000", 16)),
                roundKeys[i - 1].remainder(new BigInteger("10000000000000000", 16)).divide(new BigInteger("100000000", 16)),
                roundKeys[i - 1].remainder(new BigInteger("1000000000000000000000000", 16)).divide(new BigInteger("10000000000000000", 16)),
                roundKeys[i - 1].divide(new BigInteger("1000000000000000000000000", 16)),
            };

            // run schedule core
            t = scheduleCore(t, rconCounter);
            rconCounter += 1;

            // Calculate partial round key
            BigInteger t0 = t.xor(prevKey[3]);
            BigInteger t1 = t0.xor(prevKey[2]);
            BigInteger t2 = t1.xor(prevKey[1]);
            BigInteger t3 = t2.xor(prevKey[0]);

            // Join round key segments
            t2 = t2.multiply(new BigInteger("100000000", 16));
            t1 = t1.multiply(new BigInteger("10000000000000000", 16));
            t0 = t0.multiply(new BigInteger("1000000000000000000000000", 16));
            roundKeys[i] = t0.add(t1).add(t2).add(t3);
        }
        return roundKeys;
    }

    /**
     * representation of the input 128-bit block as an array of 8-bit integers.
     *
     * @param block of 128-bit integers
     * @return array of 8-bit integers
     */
    public static int[] splitBlockIntoCells(BigInteger block) {
        int[] cells = new int[16];
        StringBuilder blockBits = new StringBuilder(block.toString(2));

        // Append leading 0 for full "128-bit" string
        while (blockBits.length() < 128) {
            blockBits.insert(0, '0');
        }

        // split 128 to 8 bit cells
        for (int i = 0; i < cells.length; i++) {
            String cellBits = blockBits.substring(8 * i, 8 * (i + 1));
            cells[i] = Integer.parseInt(cellBits, 2);
        }

        return cells;
    }

    /**
     * Returns the 128-bit BigInteger representation of the input of an array of
     * 8-bit integers.
     *
     * @param cells that we need to merge
     * @return block of merged cells
     */
    public static BigInteger mergeCellsIntoBlock(int[] cells) {
        StringBuilder blockBits = new StringBuilder();
        for (int i = 0; i < 16; i++) {
            StringBuilder cellBits = new StringBuilder(Integer.toBinaryString(cells[i]));

            // Append leading 0 for full "8-bit" strings
            while (cellBits.length() < 8) {
                cellBits.insert(0, '0');
            }

            blockBits.append(cellBits);
        }

        return new BigInteger(blockBits.toString(), 2);
    }

    /**
     * @return ciphertext XOR key
     */
    public static BigInteger addRoundKey(BigInteger ciphertext, BigInteger key) {
        return ciphertext.xor(key);
    }

    /**
     * substitutes 8-Bit long substrings of the input using the S-Box and
     * returns the result.
     *
     * @return subtraction Output
     */
    public static BigInteger subBytes(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);

        for (int i = 0; i < 16; i++) {
            cells[i] = SBOX[cells[i]];
        }

        return mergeCellsIntoBlock(cells);
    }

    /**
     * substitutes 8-Bit long substrings of the input using the inverse S-Box
     * for decryption and returns the result.
     *
     * @return subtraction Output
     */
    public static BigInteger subBytesDec(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);

        for (int i = 0; i < 16; i++) {
            cells[i] = INVERSE_SBOX[cells[i]];
        }

        return mergeCellsIntoBlock(cells);
    }

    /**
     * Cell permutation step. Shifts cells within the rows of the input and
     * returns the result.
     */
    public static BigInteger shiftRows(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);
        int[] output = new int[16];

        // do nothing in the first row
        output[0] = cells[0];
        output[4] = cells[4];
        output[8] = cells[8];
        output[12] = cells[12];

        // shift the second row backwards by one cell
        output[1] = cells[5];
        output[5] = cells[9];
        output[9] = cells[13];
        output[13] = cells[1];

        // shift the third row backwards by two cell
        output[2] = cells[10];
        output[6] = cells[14];
        output[10] = cells[2];
        output[14] = cells[6];

        // shift the forth row backwards by tree cell
        output[3] = cells[15];
        output[7] = cells[3];
        output[11] = cells[7];
        output[15] = cells[11];

        return mergeCellsIntoBlock(output);
    }

    /**
     * Cell permutation step for decryption . Shifts cells within the rows of
     * the input and returns the result.
     */
    public static BigInteger shiftRowsDec(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);
        int[] output = new int[16];

        // do nothing in the first row
        output[0] = cells[0];
        output[4] = cells[4];
        output[8] = cells[8];
        output[12] = cells[12];

        // shift the second row forwards by one cell
        output[1] = cells[13];
        output[5] = cells[1];
        output[9] = cells[5];
        output[13] = cells[9];

        // shift the third row forwards by two cell
        output[2] = cells[10];
        output[6] = cells[14];
        output[10] = cells[2];
        output[14] = cells[6];

        // shift the forth row forwards by tree cell
        output[3] = cells[7];
        output[7] = cells[11];
        output[11] = cells[15];
        output[15] = cells[3];

        return mergeCellsIntoBlock(output);
    }

    /**
     * Applies the Rijndael MixColumns to the input and returns the result.
     */
    public static BigInteger mixColumns(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);
        int[] outputCells = new int[16];

        for (int i = 0; i < 4; i++) {
            int[] row = {
                cells[i * 4],
                cells[i * 4 + 1],
                cells[i * 4 + 2],
                cells[i * 4 + 3],
            };

            outputCells[i * 4] = MULT2[row[0]] ^ MULT3[row[1]] ^ row[2] ^ row[3];
            outputCells[i * 4 + 1] = row[0] ^ MULT2[row[1]] ^ MULT3[row[2]] ^ row[3];
            outputCells[i * 4 + 2] = row[0] ^ row[1] ^ MULT2[row[2]] ^ MULT3[row[3]];
            outputCells[i * 4 + 3] = MULT3[row[0]] ^ row[1] ^ row[2] ^ MULT2[row[3]];
        }
        return mergeCellsIntoBlock(outputCells);
    }

    /**
     * Applies the inverse Rijndael MixColumns for decryption to the input and
     * returns the result.
     */
    public static BigInteger mixColumnsDec(BigInteger ciphertext) {
        int[] cells = splitBlockIntoCells(ciphertext);
        int[] outputCells = new int[16];

        for (int i = 0; i < 4; i++) {
            int[] row = {
                cells[i * 4],
                cells[i * 4 + 1],
                cells[i * 4 + 2],
                cells[i * 4 + 3],
            };

            outputCells[i * 4] = MULT14[row[0]] ^ MULT11[row[1]] ^ MULT13[row[2]] ^ MULT9[row[3]];
            outputCells[i * 4 + 1] = MULT9[row[0]] ^ MULT14[row[1]] ^ MULT11[row[2]] ^ MULT13[row[3]];
            outputCells[i * 4 + 2] = MULT13[row[0]] ^ MULT9[row[1]] ^ MULT14[row[2]] ^ MULT11[row[3]];
            outputCells[i * 4 + 3] = MULT11[row[0]] ^ MULT13[row[1]] ^ MULT9[row[2]] ^ MULT14[row[3]];
        }
        return mergeCellsIntoBlock(outputCells);
    }

    /**
     * Encrypts the plaintext with the key and returns the result
     *
     * @param plainText which we want to encrypt
     * @param key the key for encrypt
     * @return EncryptedText
     */
    public static BigInteger encrypt(BigInteger plainText, BigInteger key) {
        BigInteger[] roundKeys = keyExpansion(key);

        // Initial round
        plainText = addRoundKey(plainText, roundKeys[0]);

        // Main rounds
        for (int i = 1; i < 10; i++) {
            plainText = subBytes(plainText);
            plainText = shiftRows(plainText);
            plainText = mixColumns(plainText);
            plainText = addRoundKey(plainText, roundKeys[i]);
        }

        // Final round
        plainText = subBytes(plainText);
        plainText = shiftRows(plainText);
        plainText = addRoundKey(plainText, roundKeys[10]);

        return plainText;
    }

    /**
     * Decrypts the ciphertext with the key and returns the result
     *
     * @param cipherText The Encrypted text which we want to decrypt
     * @return decryptedText
     */
    public static BigInteger decrypt(BigInteger cipherText, BigInteger key) {
        BigInteger[] roundKeys = keyExpansion(key);

        // Invert final round
        cipherText = addRoundKey(cipherText, roundKeys[10]);
        cipherText = shiftRowsDec(cipherText);
        cipherText = subBytesDec(cipherText);

        // Invert main rounds
        for (int i = 9; i > 0; i--) {
            cipherText = addRoundKey(cipherText, roundKeys[i]);
            cipherText = mixColumnsDec(cipherText);
            cipherText = shiftRowsDec(cipherText);
            cipherText = subBytesDec(cipherText);
        }

        // Invert initial round
        cipherText = addRoundKey(cipherText, roundKeys[0]);

        return cipherText;
    }

    public static void main(String[] args) {
        try (Scanner input = new Scanner(System.in)) {
            System.out.println("Enter (e) letter for encrpyt or (d) letter for decrypt :");
            char choice = input.nextLine().charAt(0);
            String in;
            switch (choice) {
                case 'E', 'e' -> {
                    System.out.println(
                        "Choose a plaintext block (128-Bit Integer in base 16):"
                    );
                    in = input.nextLine();
                    BigInteger plaintext = new BigInteger(in, 16);
                    System.out.println(
                        "Choose a Key (128-Bit Integer in base 16):"
                    );
                    in = input.nextLine();
                    BigInteger encryptionKey = new BigInteger(in, 16);
                    System.out.println(
                        "The encrypted message is: \n"
                        + encrypt(plaintext, encryptionKey).toString(16)
                    );
                }
                case 'D', 'd' -> {
                    System.out.println(
                        "Enter your ciphertext block (128-Bit Integer in base 16):"
                    );
                    in = input.nextLine();
                    BigInteger ciphertext = new BigInteger(in, 16);
                    System.out.println(
                        "Choose a Key (128-Bit Integer in base 16):"
                    );
                    in = input.nextLine();
                    BigInteger decryptionKey = new BigInteger(in, 16);
                    System.out.println(
                        "The deciphered message is:\n"
                        + decrypt(ciphertext, decryptionKey).toString(16)
                    );
                }
                default -> System.out.println("** End **");
            }
        }
    }
}