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;  
}

 源码下载