[JAVA] AES256 encrypt/decrypt

本文介紹AES加密，並以JAVA實作AES256加解密程式。

AES

AES(Advanced Encryption Standard)高階加密標準，最常見的為對稱加密演算法，對稱加密演算法即為加密解密方均使用同一組密鑰。

加密介紹

Ｃ ＝ Ｅ（Ｐ，Ｋ）
明文(Ｐ)使用密鑰(Ｋ)透過加密函式(Ｅ)產生密文(Ｃ)。

Ｐ ＝ Ｄ（Ｃ，Ｋ）
密文(Ｃ)使用密鑰(Ｋ)透過解密函式(Ｄ)產生明文(Ｐ)。

AES金鑰長度分類

AES加密中，明文每個分組只能是128位(16bytes)，而金鑰可以是128、192、256位，依照密鑰長度不同，加密回合數也會不同。

限制

AES加密演算法中，原始資料明文(Ｐ)長度須為16bytes的倍數，所以當資料不足16bytes時，加密前必須先將資料補足為16bytes，解密後再將之移除還原為原始資料明文。

加密步驟

依照密鑰長度不同，加密回合數(round)也不同。

回合數

AES-128 -> 10 rounds
AES-192 -> 12 rounds
AES-256 -> 14 rounds

加密函數

參考資料：維基百科

1. Add round key： 對資料(128bits or 16 bytes) ⊕ 回合金鑰。回合金鑰是由主金鑰在每回合(透過Rijndael方法產生)產生之密鑰。
2. SubBytes：矩陣中的各位元組透過一個8位元的S-box進行轉換。
   
3. ShiftRows：每一列都向左循環位移某個偏移量。
   
4. MixColumns：每一行的四個位元組透過線性變換互相結合。
   

每round行為

假設共有N rounds。

加密ROUND behaviers

ROUND 0

1. Add round key

ROUND 1 ~ ROUND (N-1)

1. SubBytes()
2. ShiftRows()
3. MixColumns()
4. AddRoundKey()

ROUND N

1. SubBytes()
2. ShiftRows()
3. AddRoundKey()

解密ROUND behaviers

以回合數相反方向開始。

ROUND N

1. AddRoundKey()
2. ShiftRows()
3. SubBytes()

ROUND (N-1) ~ ROUND 1

1. AddRoundKey()
2. MixColumns()
3. ShiftRows()
4. SubBytes()

ROUND 0

1. AddRoundKey()

實作 (JAVA)

以下內容使用JAVA實作AES-256加解密。

import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.Security;
import java.util.ArrayList;
import java.util.List;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class AES256 {
    public static final String KEY_ALGORITHM="AES";
    //public static final String CIPHER_ALGORITHM="AES/ECB/PKCS5Padding";
    public static final String CIPHER_ALGORITHM="AES/ECB/NoPadding";

    // Random generate key - not used
    public static byte[] initkey() throws Exception{
        //例項化金鑰生成器
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        KeyGenerator kg=KeyGenerator.getInstance(KEY_ALGORITHM, "BC");
        kg.init(256);
        kg.init(128);
        SecretKey secretKey=kg.generateKey();
        return secretKey.getEncoded();
    }

    // private key table
    public static byte[] initRootKey() throws Exception {
        /*return new byte[] { 0x08, 0x08, 0x04, 0x0b, 0x02, 0x0f, 0x0b, 0x0c,
        0x01, 0x03, 0x09, 0x07, 0x0c, 0x03, 0x07, 0x0a, 0x04, 0x0f,
        0x06, 0x0f, 0x0e, 0x09, 0x05, 0x01, 0x0a, 0x0a, 0x01, 0x09,
        0x06, 0x07, 0x09, 0x0d };*/

        return new byte[] { (byte) 0x9D, (byte) 0xD2, 0x00, 0x24, (byte) 0x84, 0x6A, 0x2E, (byte) 0xDA,
                0x0C, (byte) 0xDD, 0x72, 0x7B, 0x05, (byte) 0xC5, 0x6B, 0x01,
                (byte) 0xFF, 0x17, (byte) 0xCD, (byte) 0x9F, (byte) 0x8C, 0x1E, 0x3E, 0x09,
                (byte) 0xCF, 0x2F, 0x0C, 0x77, (byte) 0x87, (byte) 0xEF, (byte) 0x8A, (byte) 0xEC };
    }

    // generate key from private key
    public static Key toKey(byte[] key) throws Exception {
        SecretKey secretKey=new SecretKeySpec(key,KEY_ALGORITHM);
        return secretKey;
    }

    // encrypt 
    public byte[] encrypt(byte[] data) throws Exception {
        Key k = toKey(initRootKey());
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM, "BC");
        cipher.init(Cipher.ENCRYPT_MODE, k);
        return cipher.doFinal(data);
    }

    // decrypt 
    public byte[] decrypt(byte[] data) throws Exception {
        Key k =toKey(initRootKey());
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher=Cipher.getInstance(CIPHER_ALGORITHM, "BC");
        cipher.init(Cipher.DECRYPT_MODE, k);
        return cipher.doFinal(data);
    }

    // hex to byte convert 
    public static byte[] hexToBytes(String hexString) {

        char[] hex = hexString.toCharArray();
        //轉rawData長度減半
        int length = hex.length / 2;
        byte[] rawData = new byte[length];
        for (int i = 0; i  10000000 (8=>128)
          //然後與第二個值的二進位值作聯集ex: 10000000 | 00001100 => 10001100 (137)
          int value = (high  127)
            value -= 256;
          //最後轉回byte就OK
          rawData [i] = (byte) value;
        }
        return rawData ;
    }

    // byte to hex convert 
    public static String byte2Hex(byte[] bytes){
        StringBuffer stringBuffer = new StringBuffer();
        String temp = null;
        for (int i=0;i getStrListEnter(String inputString, int length) {
        int size = inputString.length() / length;
        if (inputString.length() % length != 0) {
            size += 1;
        }
        return getStrList(inputString, length, size);
    }
    public static List getStrList(String inputString, int length,
            int size) {
        List list = new ArrayList();
        for (int index = 0; index  str.length())
            return null;
        if (t > str.length()) {
            return str.substring(f, str.length());
        } else {
            return str.substring(f, t);
        }
    }
}

程式碼解析

首先我們使用的是AES加密算法

public static final String KEY_ALGORITHM="AES";

接著是以參數定義transformation，

public static final String CIPHER_ALGORITHM="AES/ECB/NoPadding";

參數意義如下表：

Mode表

Transform表

金鑰 (私鑰)

我們可以初始化一固定金鑰作為密鑰，也可以自動生成。

固定金鑰：
Key之byte[] 長度為16bytes。

public static byte[] initRootKey() throws Exception {return new byte[] { (byte) 0x9D, (byte) 0xD2, 0x00, 0x24, (byte) 0x84, 0x6A, 0x2E, (byte) 0xDA,
                0x0C, (byte) 0xDD, 0x72, 0x7B, 0x05, (byte) 0xC5, 0x6B, 0x01,
                (byte) 0xFF, 0x17, (byte) 0xCD, (byte) 0x9F, (byte) 0x8C, 0x1E, 0x3E, 0x09,
                (byte) 0xCF, 0x2F, 0x0C, 0x77, (byte) 0x87, (byte) 0xEF, (byte) 0x8A, (byte) 0xEC };}
                

自動生成金鑰

public static byte[] initkey() throws Exception{//例項化金鑰生成器
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        KeyGenerator kg=KeyGenerator.getInstance(KEY_ALGORITHM, "BC");
        kg.init(256);
        kg.init(128);
        SecretKey secretKey=kg.generateKey();
        return secretKey.getEncoded();}
        

加解密Cipher屬性設定

Cipher之7屬性：

cipher.init(Cipher.ENCRYPT_MODE, k);

JAVA – 加密預設金鑰長度限制

如出現以下錯誤訊息：
java.security.InvalidKeyException: Illegal key size or default parameters

請先至Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files 下載policy檔案，後將local_policy.jar及US_export_policy.jar 取代jre/security底下的兩個檔案即可解除JAVA金鑰長度問題。

可能需用到之Functions

使用不同的Padding方式會影響當分組明文不足16bytes之加密過程，明文的編碼不同也需要先轉換編碼再進行加密。下方列出進行加密前可能所需的額外明文處理funtions。

HEX String to Byte[]

// hex to byte convert 
    public static byte[] hexToBytes(String hexString) {

        char[] hex = hexString.toCharArray();
        //轉rawData長度減半
        int length = hex.length / 2;
        byte[] rawData = new byte[length];
        for (int i = 0; i  10000000 (8=>128)
          //然後與第二個值的二進位值作聯集ex: 10000000 | 00001100 => 10001100 (137)
          int value = (high  127)
            value -= 256;
          //最後轉回byte就OK
          rawData [i] = (byte) value;
        }
        return rawData ;
    }
    

Byte[] to HEX String

// byte to hex convert 
    public static String byte2Hex(byte[] bytes){
        StringBuffer stringBuffer = new StringBuffer();
        String temp = null;
        for (int i=0;i

String Split According to Input Length

 // string split s
    public static List getStrListEnter(String inputString, int length) {
        int size = inputString.length() / length;
        if (inputString.length() % length != 0) {
            size += 1;
        }
        return getStrList(inputString, length, size);
    }
    public static List getStrList(String inputString, int length,
            int size) {
        List list = new ArrayList();
        for (int index = 0; index  str.length())
            return null;
        if (t > str.length()) {
            return str.substring(f, str.length());
        } else {
            return str.substring(f, t);
        }
    }
    

以上為JAVA實作AES256加解密之方法。