AES、DES加解密方法（Java和JS編程）

在項目中經常會對一些比較隱私的內容進行加密后再傳輸，比如登錄密碼、個人信息等；

DES和AES是目前兩種比較常用的對稱加密算法；

（此篇不講原理，想了解原理可參考：DES算法、AES算法）

一、JS實現方式：

需要引入JavaScript加密庫-CryptoJS

1.DES加密以及解密：

//DES 加密
function encryptByDES(message, key) {
    var keyHex = CryptoJS.enc.Utf8.parse(key);
    var encrypted = CryptoJS.DES.encrypt(message, keyHex, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return encrypted.toString();
}
//DES 解密
function decryptByDES(ciphertext, key) {
    var keyHex = CryptoJS.enc.Utf8.parse(key);
    // direct decrypt ciphertext
    var decrypted = CryptoJS.DES.decrypt({
        ciphertext: CryptoJS.enc.Base64.parse(ciphertext)
    }, keyHex, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return decrypted.toString(CryptoJS.enc.Utf8);
}

2.AES加密以及解密：

//AES 加密
function encryptByAES(message, key) {
    var keyHex = CryptoJS.enc.Utf8.parse(key);
    var encrypted = CryptoJS.AES.encrypt(message, keyHex, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return encrypted.toString();
}
//AES 解密
function decryptByAES(ciphertext, key) {
    var keyHex = CryptoJS.enc.Utf8.parse(key);
    // direct decrypt ciphertext
    var decrypted = CryptoJS.AES.decrypt({
        ciphertext: CryptoJS.enc.Base64.parse(ciphertext)
    }, keyHex, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return decrypted.toString(CryptoJS.enc.Utf8);
}

二、Java實現

Java有兩種AES加密實現方式：

1.使用AES-128-ECB加密模式，秘鑰必須為16位字符串（128bit = 16 * 8bit）；這種方式與上面JS的AES可以前后端配合一起使用；

// 加密
public static String Encrypt(String sSrc, String sKey) throws Exception {
    if (sKey == null) {
        System.out.print("Key為空null");
        return null;
    }
    // 判斷Key是否為16位
    if (sKey.length() != 16) {
        System.out.print("Key長度不是16位");
        return null;
    }
    byte[] raw = sKey.getBytes("utf-8");
    SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
    Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");//"算法/模式/補碼方式"
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
    byte[] encrypted = cipher.doFinal(sSrc.getBytes("utf-8"));
    //此處使用BASE64做轉碼功能，同時能起到2次加密的作用。
    //return new Base64().encodeToString(encrypted);
    return Base64.encode(encrypted);
}

// 解密
public static String Decrypt(String sSrc, String sKey) throws Exception {
    try {
        // 判斷Key是否正確
        if (sKey == null) {
            System.out.print("Key為空null");
            return null;
        }
        // 判斷Key是否為16位
        if (sKey.length() != 16) {
            System.out.print("Key長度不是16位");
            return null;
        }
        byte[] raw = sKey.getBytes("utf-8");
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, skeySpec);
        //先用base64轉碼
        //byte[] encrypted1 = new Base64().decode(sSrc);
        byte[] encrypted1 = Base64.decode(sSrc);
        try {
            byte[] original = cipher.doFinal(encrypted1);
            String originalString = new String(original,"utf-8");
            return originalString;
        } catch (Exception e) {
            System.out.println(e.toString());
            return null;
        }
    } catch (Exception ex) {
        System.out.println(ex.toString());
        return null;
    }
}

 

2.下面這種方式對加密解密的秘鑰沒有長度限制（代碼中進行了補全到相應位數），但不能和JS的實現配合使用，將算法名稱和秘鑰的編碼位數進行更改就變為了DES加密

//加密
public static String encrypt(String content, String password) {  
    try {
        //將秘鑰補全為128位
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        //若想改為DES加密，則需要將秘鑰位數改為64位
        kgen.init(128, new SecureRandom(password.getBytes()));
        SecretKey secretKey = kgen.generateKey();  
        byte[] enCodeFormat = secretKey.getEncoded();  
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        //創建密碼器
        Cipher cipher = Cipher.getInstance("AES");
        byte[] byteContent = content.getBytes("utf-8");
        //初始化  
        cipher.init(Cipher.ENCRYPT_MODE, key);
        //加密 
        byte[] result = cipher.doFinal(byteContent);
        //Base64轉碼
        return Base64.encode(result); 
    } catch (NoSuchAlgorithmException e) {  
        e.printStackTrace();  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
    } catch (InvalidKeyException e) {  
        e.printStackTrace();  
    } catch (UnsupportedEncodingException e) {  
        e.printStackTrace();  
    } catch (IllegalBlockSizeException e) {  
        e.printStackTrace();  
    } catch (BadPaddingException e) {  
        e.printStackTrace();  
    }  
    return null;
}

//解密
public static String decrypt(String content, String password) throws Exception {  
    try {
        //將秘鑰補全為128位
        KeyGenerator kgen = KeyGenerator.getInstance("AES");
        //若想改為DES加密，則需要將秘鑰位數改為64位
        kgen.init(128, new SecureRandom(password.getBytes()));  
        SecretKey secretKey = kgen.generateKey();  
        byte[] enCodeFormat = secretKey.getEncoded();  
        SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
        //創建密碼器             
        Cipher cipher = Cipher.getInstance("AES");
        //初始化
        cipher.init(Cipher.DECRYPT_MODE, key);
        //Base64轉碼
        byte[] encrypted1 = Base64.decode(content);
        //解密
        byte[] result = cipher.doFinal(encrypted1);
        //二進制轉為字符串
        return new String(result, "utf-8");
    } catch (NoSuchAlgorithmException e) {  
        e.printStackTrace();  
    } catch (NoSuchPaddingException e) {  
        e.printStackTrace();  
    } catch (InvalidKeyException e) {  
        e.printStackTrace();  
    } catch (IllegalBlockSizeException e) {  
        e.printStackTrace();  
    } catch (BadPaddingException e) {  
        e.printStackTrace();  
    }  
    return null;  
}

 加密解密時密碼器的輸入輸出都為2進制數組，這里我們用Base64在加解密的中間過程中進行了轉碼，所以可以以字符串形式展示加密后的密文，也可以使用下面的方法將二進制數組轉換為16進制的字符串來表示，同樣起到轉換的作用

//將二進制數組轉化為16進制字符串
public static String parseByte2HexStr(byte buf[]) {  
    StringBuffer sb = new StringBuffer();  
    for (int i = 0; i < buf.length; i++) {  
        String hex = Integer.toHexString(buf[i] & 0xFF);  
        if (hex.length() == 1) {  
            hex = '0' + hex;  
        }  
        sb.append(hex.toUpperCase());  
    }  
    return sb.toString();  
}
//將16進制字符串轉化為二進制數組
public static byte[] parseHexStr2Byte(String hexStr) {  
    if (hexStr.length() < 1)  
        return new byte[0];  
    byte[] result = new byte[hexStr.length()/2];  
    for (int i = 0;i< hexStr.length()/2; i++) {  
        int high = Integer.parseInt(hexStr.substring(i*2, i*2+1), 16);  
        int low = Integer.parseInt(hexStr.substring(i*2+1, i*2+2), 16);  
        result[i] = (byte) (high * 16 + low);  
    }  
    return result;  
}

 源碼下載