AES/ECB/PKCS5Padding/PKCS7Padding 128位密钥（带密钥补位功能）加密解密

今天客户说发解密算法过来，本来以为拿来的是代码直接用，
没想到就直接给了我个网站http://www.seacha.com/tools/aes.html
和他们用的算法模式+密钥。
以前还真没玩过AES加密解密，下面是今天研究的结果。

实现结果:
算法：AES
模式：ECB
密钥长度：128位
密钥：自己填（代码中带补位功能）
补码方式：PKCS5Padding/PKCS7Padding （这两个补码方式出来的结果都一样，好像没区别）
加密结果编码方式：十六进制/base64（加密解密的方法里面两种编码方式的代码都有）

AES.java：

package com.sun.aes;

import java.math.BigInteger;

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

import org.apache.commons.codec.binary.Base64;  
import org.apache.commons.codec.binary.Hex;
  
public class AES {
	
    /** 
     * 加密
     * @param String src 加密字符串 
     * @param String key 密钥
     * @return 加密后的字符串 
     */  
    public static String Encrypt(String src, String key) throws Exception {
    	// 判断密钥是否为空
        if (key == null) {
            System.out.print("密钥不能为空");
            return null;
        }
        
        // 密钥补位
        int plus= 16-key.length();        
        byte[] data = key.getBytes("utf-8");
        byte[] raw = new byte[16];
        byte[] plusbyte={ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
        for(int i=0;i<16;i++)
        {
        	if (data.length > i)
        		raw[i] = data[i];
        	else
        		raw[i] = plusbyte[plus];
        }
        
        SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");	// 算法/模式/补码方式 
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
        byte[] encrypted = cipher.doFinal(src.getBytes("utf-8"));
 
        //return new Base64().encodeToString(encrypted);//base64
        return binary(encrypted, 16); //十六进制
    }

    /** 
     * 解密
     * @param String src 解密字符串 
     * @param String key 密钥
     * @return 解密后的字符串 
     */  
    public static String Decrypt(String src, String key) throws Exception {
        try {
            // 判断Key是否正确
            if (key == null) {
                System.out.print("Key为空null");
                return null;
            }

            // 密钥补位
            int plus= 16-key.length();            
            byte[] data = key.getBytes("utf-8");
            byte[] raw = new byte[16];
            byte[] plusbyte={ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
            for(int i=0;i<16;i++)
            {
            	if (data.length > i)
            		raw[i] = data[i];
            	else
            		raw[i] = plusbyte[plus];
            }
            
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            
            //byte[] encrypted1 = new Base64().decode(src);//base64
            byte[] encrypted1 = toByteArray(src);//十六进制
            
            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;
        }
    }
    
    /** 
     * 将byte[]转为各种进制的字符串 
     * @param bytes byte[] 
     * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制 
     * @return 转换后的字符串 
     */  
    public static String binary(byte[] bytes, int radix){  
        return new BigInteger(1, bytes).toString(radix);	// 这里的1代表正数  
    }
    
    /**
     * 16进制的字符串表示转成字节数组
     *
     * @param hexString 16进制格式的字符串            
     * @return 转换后的字节数组
     **/
    public static byte[] toByteArray(String hexString) {
        if (hexString.isEmpty())
            throw new IllegalArgumentException("this hexString must not be empty");

        hexString = hexString.toLowerCase();
        final byte[] byteArray = new byte[hexString.length() / 2];
        int k = 0;
        for (int i = 0; i < byteArray.length; i++) {//因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
            byteArray[i] = (byte) (high << 4 | low);
            k += 2;
        }
        return byteArray;
    }
    
    public static void main(String[] args) throws Exception {
    	// 密钥
        String key = "smph20151208shao";
        // 需要加密的字符串
        String src = "出版社";
        
        System.out.println(src);
        
        // 加密
        String enString = Encrypt(src, key);
        System.out.println("加密后的字串是：" + enString);
 
        // 解密
        String DeString = Decrypt(enString, key);
        System.out.println("解密后的字串是：" + DeString);
    }

}  

运行结果：
出版社
加密后的字串是：c4735c066ad590cb11e0fd6084592df2

解密后的字串是：出版社

-------------------------------------------------补充-------------------------------------------------

今天拿到了客户加密后的文件，发觉XML是整个文件加密，且按照每三个字符加密，加密后的字符串带换行，XML开始位置竟然还有乱码。
修改后的解密代码如下：

    /** 
     * 解密
     * @param String src 解密字符串 
     * @param String key 密钥
     * @return 解密后的字符串 
     */  
    public static String decrypt(String src, String key) throws Exception {
        try {
            // 判断Key是否正确
            if (key == null) {
                System.out.print("Key为空null");
                return null;
            }

            // 密钥补位
            int plus= 16-key.length();            
            byte[] data = key.getBytes("utf-8");
            byte[] raw = new byte[16];
            byte[] plusbyte={ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f};
            for(int i=0;i<16;i++)
            {
            	if (data.length > i)
            		raw[i] = data[i];
            	else
            		raw[i] = plusbyte[plus];
            }
            
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec);
            
            //byte[] encrypted1 = new Base64().decode(src);//base64
            byte[] encrypted1 = toByteArray(src);//十六进制
            
            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;
        }
    }
    
    /** 
     * 将byte[]转为各种进制的字符串 
     * @param bytes byte[] 
     * @param radix 可以转换进制的范围，从Character.MIN_RADIX到Character.MAX_RADIX，超出范围后变为10进制 
     * @return 转换后的字符串 
     */  
    public static String binary(byte[] bytes, int radix){  
        return new BigInteger(1, bytes).toString(radix);	// 这里的1代表正数  
    }
    
    /**
     * 16进制的字符串表示转成字节数组
     *
     * @param hexString 16进制格式的字符串            
     * @return 转换后的字节数组
     **/
    public static byte[] toByteArray(String hexString) {
        if (hexString.isEmpty())
            throw new IllegalArgumentException("this hexString must not be empty");

        hexString = hexString.toLowerCase();
        final byte[] byteArray = new byte[hexString.length() / 2];
        int k = 0;
        for (int i = 0; i < byteArray.length; i++) {//因为是16进制，最多只会占用4位，转换成字节需要两个16进制的字符，高位在先
            byte high = (byte) (Character.digit(hexString.charAt(k), 16) & 0xff);
            byte low = (byte) (Character.digit(hexString.charAt(k + 1), 16) & 0xff);
            byteArray[i] = (byte) (high << 4 | low);
            k += 2;
        }
        return byteArray;
    }
    
    /**
     * 执行解码并生成解码后文件
     *
     * @param sourceFile 加密文件
     * @param targetFile 解密后生成文件
     **/
    public static void decryptFile(String sourceFile, String targetFile) {
    	// 密钥
        String key = "smbk20160101shao";
        
        try{
	        File file = new File(targetFile);
	        if (file.exists())
	        	file.delete();
	        file.createNewFile();
	    	
	        // read net source file to local target file
	    	URL url = new URL(encodeUrlToUTF8(sourceFile));  
	        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));  
	        String s;
	        while ((s = reader.readLine()) != null) {
	        	writeFile(targetFile, decrypt(changeString(s), key));
	        }
	        reader.close();
        }
	catch(Exception e)
	{
            e.printStackTrace();
	}
    }

    /**
     * 
     * Url中的中文转换
     * 
     */
    public static String encodeUrlToUTF8(String url) throws UnsupportedEncodingException{  
    StringBuffer sb = new StringBuffer();  
        for (int i = 0; i < url.length(); i++) {  
            String s = url.substring(i, i + 1);  
            byte[] bytes = s.getBytes("UTF-8"); 
            // 中文字符是2个字节，符号和英文为1个字节  
            if (bytes.length == 1) {
                if (bytes[0] == ' ')  
                    sb.append("%20");  
                else  
                    sb.append(s);  
            } else {  
                sb.append(URLEncoder.encode(s, "UTF-8"));
            }  
        }  
        return sb.toString();
    }  
	

    /**
     * 
     * 除去乱码
     * 
     */
    private static String changeString(String str){
 	String str_Result = "", str_OneStr = "";  
   	for (int z = 0; z < str.length(); z++) {  
	    str_OneStr = str.substring(z, z + 1);  
	    if (!str_OneStr.matches("[\u4e00-\u9fa5]+")) {  
	        if (str_OneStr.matches("[\\x00-\\x7F]+")) {  
	            str_Result = str_Result + str_OneStr;  
	        }  
	    }
	}
        return str_Result;
    }

    /**
     * 
     * 将内容写入输出文件
     * 
     */
    public static void writeFile(String fileName, String content) throws IOException{
        FileWriter fw = new FileWriter(fileName, true);
        fw.write(content);
        //刷新缓冲区
        fw.flush();
        //关闭文件流对象
        fw.close();
    }

调用：

decryptFile("http://localhost:8080/Test/Source/test.xml", "D:/Test/test.xml")

-------------------------------------------------继续补充-------------------------------------------------

如果要在前台用JS加密解密，需要CryptoJS的js包
需要引入3个文件：

<script type="text/javascript" src="${ctxStatic}/modules/smph/js/CryptoJS/rollups/aes.js"></script>
<script type="text/javascript" src="${ctxStatic}/modules/smph/js/CryptoJS/components/mode-ecb-min.js"></script>
<script type="text/javascript" src="${ctxStatic}/modules/smph/js/CryptoJS/components/pad-nopadding-min.js"></script>

JS：

<script type="text/javascript">  
        var key = CryptoJS.enc.Utf8.parse("1234567890123456"); 
        function Encrypt(word){
            srcs = CryptoJS.enc.Utf8.parse(word);
            var encrypted = CryptoJS.AES.encrypt(srcs, key, { mode:CryptoJS.mode.ECB,padding: CryptoJS.pad.Pkcs7});
            return encrypted.ciphertext.toString().toUpperCase();
        }

        function Decrypt(word){
            var encryptedHexStr = CryptoJS.enc.Hex.parse(word);
            var srcs = CryptoJS.enc.Base64.stringify(encryptedHexStr);
            var decrypt = CryptoJS.AES.decrypt(srcs, key, { mode:CryptoJS.mode.ECB,padding: CryptoJS.pad.Pkcs7});
            var decryptedStr = decrypt.toString(CryptoJS.enc.Utf8);
            return decryptedStr.toString();
        }

<span style="white-space:pre">	</span>var source = "ABC";
        var target = Encrypt(source);
<span style="white-space:pre">	</span>console.log(target);
<span style="white-space:pre">	</span>console.log(Decrypt(target));
</script>