title: AES Encryption program do not work correctly on IDEs
body: <p><strong>Program</strong></p>
  
  <pre><code>import java.nio.charset.StandardCharsets;
  import java.util.Base64;
  public class AesCtr256 {
  
  // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1]
  private static final int[] sBox = new int[] { 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 };
  // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
  private static final int[][] rCon = new int[][] { new int[] { 0x00, 0x00, 0x00, 0x00 }, // 0
          new int[] { 0x01, 0x00, 0x00, 0x00 }, // 1
          new int[] { 0x02, 0x00, 0x00, 0x00 }, // 2
          new int[] { 0x04, 0x00, 0x00, 0x00 }, // 3
          new int[] { 0x08, 0x00, 0x00, 0x00 }, // 4
          new int[] { 0x10, 0x00, 0x00, 0x00 }, // 5
          new int[] { 0x20, 0x00, 0x00, 0x00 }, // 6
          new int[] { 0x40, 0x00, 0x00, 0x00 }, // 7
          new int[] { 0x80, 0x00, 0x00, 0x00 }, // 8
          new int[] { 0x1b, 0x00, 0x00, 0x00 }, // 9
          new int[] { 0x36, 0x00, 0x00, 0x00 }// 10
  };
  private static final String UTF8 = "UTF-8";
  
  public static void main(String[] args) throws Exception {
      // Security.setProperty("crypto.policy", "unlimited");
      final int maxKeySize = javax.crypto.Cipher.getMaxAllowedKeyLength("AES");
      System.out.println("Max Key Size for AES : " + maxKeySize);
  
      final String data = "My Encrypted String";
      final String key = "3e6cf9b346544bbb46ec99e33a9e0bcc";
      final String encrypted = encrypt(data, key, 256);
      System.out.println("Encrypted string=" + encrypted);
      System.out.println();
      final String decrypted = decrypt(encrypted, key);
      System.out.println("Decrypted string=" + decrypted);
  }
  
  /**
   * AES Cipher function: encrypt 'input' state with Rijndael algorithm [§5.1]; applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage.
   *
   * @param {number[]} input - 16-byte (128-bit) input state array.
   * @param {number[][]} w - Key schedule as 2D byte-array (Nr+1 x Nb bytes).
   * @returns {number[]} Encrypted output state array.
   */
  private static int[] cipher(int[] input, int[][] w) {
      final int Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
      final int Nr = w.length / Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys
  
      int[][] state = new int[4][];// [[],[],[],[]]; // initialise 4xNb byte-array 'state' with input [§3.4]
      for (int i = 0; i &lt; 4 * Nb; i++) {
          if (state[i % 4] == null) {
              state[i % 4] = new int[4];
          }
          state[i % 4][(int) Math.floor((double) i / 4)] = input[i];
      }
  
      state = addRoundKey(state, w, 0, Nb);
  
      for (int round = 1; round &lt; Nr; round++) {
          state = subBytes(state, Nb);
          state = shiftRows(state, Nb);
          state = mixColumns(state, Nb);
          state = addRoundKey(state, w, round, Nb);
      }
  
      state = subBytes(state, Nb);
      state = shiftRows(state, Nb);
      state = addRoundKey(state, w, Nr, Nb);
  
      final int[] output = new int[4 * Nb]; // convert state to 1-d array before returning [§3.4]
      for (int i = 0; i &lt; 4 * Nb; i++) {
          output[i] = state[i % 4][(int) Math.floor((double) i / 4)];
      }
  
      return output;
  }
  
  /**
   * Perform key expansion to generate a key schedule from a cipher key [§5.2].
   *
   * @param {number[]} key - Cipher key as 16/24/32-byte array.
   * @returns {number[][]} Expanded key schedule as 2D byte-array (Nr+1 x Nb bytes).
   */
  private static int[][] keyExpansion(int[] key) {
      final int Nb = 4; // block size (in words): no of columns in state (fixed at 4 for AES)
      final int Nk = key.length / 4; // key length (in words): 4/6/8 for 128/192/256-bit keys
      final int Nr = Nk + 6; // no of rounds: 10/12/14 for 128/192/256-bit keys
  
      final int[][] w = new int[Nb * (Nr + 1)][Nb];
      int[] temp = new int[4];
  
      // initialise first Nk words of expanded key with cipher key
      for (int i = 0; i &lt; Nk; i++) {
          final int[] r = new int[] { key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3] };
          w[i] = r;
      }
  
      // expand the key into the remainder of the schedule
      for (int i = Nk; i &lt; (Nb * (Nr + 1)); i++) {
          w[i] = new int[4];
          for (int t = 0; t &lt; 4; t++) {
              temp[t] = w[i - 1][t];
          }
          // each Nk'th word has extra transformation
          if (i % Nk == 0) {
              temp = subWord(rotWord(temp));
              for (int t = 0; t &lt; 4; t++) {
                  temp[t] ^= rCon[i / Nk][t];
              }
          }
          // 256-bit key has subWord applied every 4th word
          else if (Nk &gt; 6 &amp;&amp; i % Nk == 4) {
              temp = subWord(temp);
          }
          // xor w[i] with w[i-1] and w[i-Nk]
          for (int t = 0; t &lt; 4; t++) {
              w[i][t] = (w[i - Nk][t] ^ temp[t]);
          }
      }
  
      return w;
  }
  
  /**
   * Apply SBox to state S [§5.1.1]
   *
   * @private
   */
  private static int[][] subBytes(int[][] s, int Nb) {
      for (int r = 0; r &lt; 4; r++) {
          for (int c = 0; c &lt; Nb; c++) {
              s[r][c] = sBox[s[r][c]];
          }
      }
      return s;
  }
  
  /**
   * Shift row r of state S left by r bytes [§5.1.2]
   *
   * @private
   */
  private static int[][] shiftRows(int[][] s, int Nb) {
      final int[] t = new int[4];
      for (int r = 1; r &lt; 4; r++) {
          for (int c = 0; c &lt; 4; c++) {
              t[c] = s[r][(c + r) % Nb]; // shift into temp copy
          }
          // and copy back
          System.arraycopy(t, 0, s[r], 0, 4);
      } // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
      return s; // see asmaes.sourceforge.net/rijndael/rijndaelImplementation.pdf
  }
  
  /**
   * Combine bytes of each col of state S [§5.1.3]
   *
   * @private
   */
  private static int[][] mixColumns(int[][] s, int Nb) {
      for (int c = 0; c &lt; 4; c++) {
          final int[] a = new int[4]; // 'a' is a copy of the current column from 's'
          final int[] b = new int[4]; // 'b' is a•{02} in GF(2^8)
          for (int i = 0; i &lt; 4; i++) {
              a[i] = s[i][c];
              b[i] = (s[i][c] &amp; 0x80) &gt; 0 ? (s[i][c] &lt;&lt; 1 ^ 0x011b) : (s[i][c] &lt;&lt; 1);
          }
          // a[n] ^ b[n] is a•{03} in GF(2^8)
          s[0][c] = (b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]); // {02}•a0 + {03}•a1 + a2 + a3
          s[1][c] = (a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]); // a0 • {02}•a1 + {03}•a2 + a3
          s[2][c] = (a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]); // a0 + a1 + {02}•a2 + {03}•a3
          s[3][c] = (a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]); // {03}•a0 + a1 + a2 + {02}•a3
      }
      return s;
  }
  
  /**
   * Xor Round Key into state S [§5.1.4]
   *
   * @private
   */
  private static int[][] addRoundKey(int[][] state, int[][] w, int rnd, int Nb) {
      for (int r = 0; r &lt; 4; r++) {
          for (int c = 0; c &lt; Nb; c++) {
              state[r][c] ^= w[rnd * 4 + c][r];
          }
      }
      return state;
  }
  
  /**
   * Apply SBox to 4-byte word w
   *
   * @private
   */
  private static int[] subWord(int[] w) {
      for (int i = 0; i &lt; 4; i++) {
          w[i] = sBox[w[i]];
      }
      return w;
  }
  
  /**
   * Rotate 4-byte word w left by one byte
   *
   * @private
   */
  private static int[] rotWord(int[] w) {
      final int tmp = w[0];
      System.arraycopy(w, 1, w, 0, 3);
      w[3] = tmp;
      return w;
  }
  
  public static String encrypt(String plaintext, String password, int nBits) throws Exception {
  
      final int blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
      if (!(nBits == 128 || nBits == 192 || nBits == 256)) {
          return ""; // standard allows 128/192/256 bit keys
      }
      // note PHP (5) gives us plaintext and password in UTF8 encoding!
      password = UTF8Encode(password);
      plaintext = UTF8Encode(plaintext);
      final int nBytes = nBits / 8; // no bytes in key
      final int[] pwBytes = new int[nBytes];
      for (int i = 0; i &lt; nBytes; i++) {
          pwBytes[i] = Float.isNaN(password.charAt(i)) ? 0 : password.charAt(i);
      }
      int[] key = cipher(pwBytes, keyExpansion(pwBytes));
      // expand key to 16/24/32 bytes long
      final int bytesExpand = nBytes - 16;
      if (bytesExpand &gt; 0) {
          final int keyOriginalLength = key.length;
          final int[] expandKey = new int[bytesExpand];
          final int[] endKey = new int[keyOriginalLength + bytesExpand];
          System.arraycopy(key, 0, expandKey, 0, bytesExpand);// initial expandKey
          System.arraycopy(key, 0, endKey, 0, key.length);// copy all from key to endKey
          System.arraycopy(expandKey, 0, endKey, key.length, expandKey.length);
          key = endKey;
      }
      final int[] counterBlock = new int[16];
      final long nonce = 1543699; // System.currentTimeMillis();
      final long nonceMs = nonce % 1000;
      final long nonceSec = (long) Math.floor(nonce / 1000);
      final long nonceRnd = 27096; // (long)Math.floor(Math.random() * 0xffff);
      for (int i = 0; i &lt; 2; i++) {
          counterBlock[i] = (int) ((nonceMs &gt;&gt;&gt; i * 8) &amp; 0xff);
      }
      for (int i = 0; i &lt; 2; i++) {
          counterBlock[i + 2] = (int) ((nonceRnd &gt;&gt;&gt; i * 8) &amp; 0xff);
      }
      for (int i = 0; i &lt; 4; i++) {
          counterBlock[i + 4] = (int) ((nonceSec &gt;&gt;&gt; i * 8) &amp; 0xff);
      }
      final StringBuilder ctrTxt = new StringBuilder();
      for (int i = 0; i &lt; 8; i++) {
          ctrTxt.append((char) counterBlock[i]);
      }
      // generate key schedule
      final int[][] keySchedule = keyExpansion(key);
      // separate ciphertext into blocks (skipping past initial 8 bytes)
      final int nBlocks = (int) Math.ceil((plaintext.length()) / (float) blockSize);
      final String[] ciphertxt = new String[nBlocks];
      final byte[][] bytearray = new byte[nBlocks + 1][];
      bytearray[0] = ctrTxt.toString().getBytes();
      for (int b = 0; b &lt; nBlocks; b++) {
          // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
          // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
          for (int c = 0; c &lt; 4; c++) {
              counterBlock[15 - c] = (b &gt;&gt;&gt; c * 8) &amp; 0xff;
          }
          for (int c = 0; c &lt; 4; c++) {
              counterBlock[15 - c - 4] = b / 0x10000000 &gt;&gt;&gt; c * 8; /* 0x100000000 */
          }
          final int[] cipherCntr = cipher(counterBlock, keySchedule);
          // block size is reduced on final block
          final int blockLength = (b &lt; nBlocks - 1) ? blockSize : (plaintext.length() - 1) % blockSize + 1;
          final byte[] cipherByte = new byte[blockLength];
          for (int i = 0; i &lt; blockLength; i++) { // -- xor plaintext with ciphered counter byte-by-byte --
              cipherByte[i] = (byte) (cipherCntr[i] ^ ord(substr(plaintext, b * blockSize + i, 1)));
          }
          ciphertxt[b] = new String(cipherByte);
          bytearray[b + 1] = cipherByte;
      }
      int bigArraySize = 0;
      for (final byte[] bytes : bytearray) {
          bigArraySize += bytes.length;
      }
      final byte[] bigArray = new byte[bigArraySize];
      copySmallArraysToBigArray(bytearray, bigArray);
      return Base64.getEncoder().withoutPadding().encodeToString(bigArray);
      // return new String(bigArray, StandardCharsets.UTF_8);
  }
  
  private static void copySmallArraysToBigArray(byte[][] smallArrays, byte[] bigArray) {
      int currentOffset = 0;
      for (final byte[] currentArray : smallArrays) {
          System.arraycopy(currentArray, 0, bigArray, currentOffset, currentArray.length);
          currentOffset += currentArray.length;
      }
  }
  
  public static int ord(String s) {
      // return s.length() &gt; 0 ? (s.getBytes(StandardCharsets.UTF_8)[0] &amp; 0xff) : 0;
      return s.length() &gt; 0 ? (s.getBytes()[0] &amp; 0xff) : 0;
  }
  
  public static int ord(char c) {
      return c &lt; 0x80 ? c : ord(Character.toString(c));
  }
  
  private static String substr(String string, int from, int to) {
      final String substring = string.substring(string.length() - Math.abs(from));
      if (from &lt; 0 &amp;&amp; to &lt; 0) {
          if (Math.abs(from) &gt; Math.abs(to)) {
              return substring.substring(substring.length() - Math.abs(to));
          }
          else {
              return "";
          }
      }
      else if (from &gt;= 0 &amp;&amp; to &lt; 0) {
          final String s = string.substring(from);
          if (Math.abs(to) &gt;= s.length()) {
              return "";
          }
          else {
              return s.substring(0, s.length() - Math.abs(to));
          }
      }
      else if (from &lt; 0) {
          if (to &gt;= substring.length()) {
              return substring;
          }
          return substring.substring(0, to);
      }
      else {
          final String s = string.substring(Math.abs(from));
          if (to &gt;= s.length()) {
              return s;
          }
          else {
              return s.substring(0, Math.abs(to));
          }
      }
  }
  
  /**
   * Decrypt a text encrypted by AES in counter mode of operation
   *
   * @param {string} ciphertext - Source text to be encrypted.
   * @param {string} password - Password to use to generate a key.
   * @param {number} nBits - Number of bits to be used in the key; 128 / 192 / 256.
   * @returns {string} Decrypted text
   * @example
   */
  private static String decrypt(String ciphertext, String password) throws Exception {
      String plaintext = "";
      // try {
      final int blockSize = 16; // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  
      ciphertext = base64Decoder(ciphertext);
      password = UTF8Encode(password);
  
      // use AES to encrypt password (mirroring encrypt routine)
  
      final int nBytes = 256 / 8; // no bytes in key
      final int[] pwBytes = new int[nBytes];
      for (int i = 0; i &lt; nBytes; i++) {
          pwBytes[i] = Float.isNaN(password.charAt(i)) ? 0 : password.charAt(i);
      }
  
      int[] key = cipher(pwBytes, keyExpansion(pwBytes));
      // expand key to 16/24/32 bytes long
      final int bytesExpand = nBytes - 16;
  
      final int keyOriginalLength = key.length;
      final int[] expandKey = new int[bytesExpand];
      final int[] endKey = new int[keyOriginalLength + bytesExpand];
      System.arraycopy(key, 0, expandKey, 0, bytesExpand);// initial expandKey
      System.arraycopy(key, 0, endKey, 0, key.length);// copy all from key to endKey
      System.arraycopy(expandKey, 0, endKey, key.length, expandKey.length);
      key = endKey;
  
      // recover nonce from 1st 8 bytes of ciphertext
      final int[] counterBlock = new int[16];
      final String ctrTxt = ciphertext.substring(0, 8);
      for (int i = 0; i &lt; 8; i++) {
          counterBlock[i] = ctrTxt.charAt(i);
      }
  
      // generate key schedule
      final int[][] keySchedule = keyExpansion(key);
  
      // separate ciphertext into blocks (skipping past initial 8 bytes)
      final int nBlocks = (int) Math.ceil((ciphertext.length() - 8) / (float) blockSize);
      final String[] cipherArr = new String[nBlocks];
      for (int b = 0; b &lt; nBlocks; b++) {
          final int start = 8 + b * blockSize;
          final int end = 8 + b * blockSize + blockSize;
          if (end &gt;= ciphertext.length()) {
              cipherArr[b] = UTF8Encode(ciphertext.substring(start));
          }
          else {
              cipherArr[b] = UTF8Encode(ciphertext.substring(start, end));
          }
      }
      // ciphertext is now array of block-length strings, ³F.àiþ±wãì¿,ß°d
      // plaintext will get generated block-by-block into "³F.àiþ±wãì¿,ß°" array of block-length strings
      final String[] plaintxt = new String[cipherArr.length];
      // Expand CounterBlock
      for (int b = 0; b &lt; nBlocks; b++) {
          // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
          for (int c = 0; c &lt; 4; c++) {
              counterBlock[15 - c] = (b &gt;&gt; c * 8) &amp; 0xff;
          }
          for (int c = 0; c &lt; 4; c++)
          // counterBlock[15 - c - 4] = (b / 0x100000000 &gt;&gt;&gt; c * 8);
          {
              counterBlock[15 - c - 4] = 0;
          }
  
          final int[] cipherCntr = cipher(counterBlock, keySchedule); // encrypt counter block
          final char[] plaintxtByte = new char[cipherArr[b].length()];
          for (int i = 0; i &lt; cipherArr[b].length(); i++) {
  
              plaintxtByte[i] = (char) (cipherCntr[i] ^ cipherArr[b].charAt(i));
          }
          plaintxt[b] = String.copyValueOf(plaintxtByte);
      }
  
      // join array of blocks into single plaintext string
      plaintext = joinArray(plaintxt);// plaintxt.Join('');
  
      // join array of blocks into single plaintext string
      plaintext = UTF8Decode(plaintext);// decode from UTF8 back to Unicode multi-byte chars
  
      return plaintext;
  }
  
  private static String joinArray(Object[] source) {
      final StringBuilder dest = new StringBuilder();
      for (final Object o : source) {
          dest.append((String) o);
      }
      return dest.toString();
  }
  
  private static String UTF8Decode(String s) throws Exception {
  
      final byte[] utf8Bytes = new byte[s.length()];
      for (int i = 0; i &lt; s.length(); ++i) {
          // Debug.Assert( 0 &lt;= utf8String[i] &amp;&amp; utf8String[i] &lt;= 255, "the char must be in byte's range");
          utf8Bytes[i] = (byte) s.charAt(i);
      }
  
      return new String(utf8Bytes, StandardCharsets.UTF_8);
  }
  
  private static String base64Decoder(String data) throws Exception {
  
      final byte[] b = Base64.getDecoder().decode(data.getBytes(StandardCharsets.ISO_8859_1));
      // byte[] b = DatatypeConverter.parseBase64Binary(data);
      return new String(b, StandardCharsets.ISO_8859_1);
  }
  
  private static String UTF8Encode(String s) throws Exception {
  
      return new String(s.getBytes(StandardCharsets.UTF_8), StandardCharsets.UTF_8);
  }
  }
  </code></pre>
  
  <p><strong>Expected Output</strong> <em>(It runs correctly with cmd)</em></p>
  
  <p><a href="https://i.stack.imgur.com/zpE9f.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/zpE9f.png" alt="enter image description here"></a></p>
  
  <p>Actual output on IDEs (Intellij,Eclipse)</p>
  
  <pre><code>Max Key Size for AES : 2147483647
  Encrypted string=wrsCw5hpBwYAAGNJ2u4oXMphxxzlyt+hHAm5tVc
  
  Decrypted string=��\��ʶ����r?3�cd�^
  </code></pre>
  
  <p>JDK that I'm using </p>
  
  <pre><code>java version "11.0.5" 2019-10-15 LTS
  Java(TM) SE Runtime Environment 18.9 (build 11.0.5+10-LTS)
  Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.5+10-LTS, mixed mode)
  </code></pre>