Java中如何使用AES进行对称加密呢?

下文笔者讲述使用AES进行对称加密解密的方法及示例分享
学习完本篇之后,你将彻底掌握AES对称加密的相关操作说明,如下所示

对称加密(Symmetric Cryptography)
   对称加密是最快速、最简单的一种加密方式
       加密(encryption)与解密(decryption)用的是同样的密钥(secret key)。
   对称加密
       通常使用的是相对较小的密钥
        一般小于256bit。
		当密钥越大，加密越强，但加密与解密的过程越慢。

对称加密的缺点:
    密钥的管理与分配,需要密钥发送给对方,这种操作会导致一些安全问题

非对称加密(Asymmetric Cryptography)
    非对称加密为数据的加密与解密提供一个非常安全的方法
      它使用一对密钥：
	     公钥(public key)和私钥(private key)
		 私钥只能由一方安全保管，不能外泄，而公钥则可以发给任何请求它的人
		 非对称加密使用这对密钥中的一个进行加密，而解密则需要另一个密钥

非对称算法：
      加密解密的速度比较慢

非对称加密算法的优点:
     密钥传输方便
	  常见的非对称加密算法为RSA、ECC和EIGamal

例:对称加密和非对称加密的示例分享

String input = "uy45fd76dgty:908:234:8907432122";
String key = "56y78ui905443d45g2cw098563ghj876";
String EncryptedPassword = SymmetricCipher.AES_Encrypt(input, key);
assertEquals(input, SymmetricCipher.AES_Decrypt(EncryptedPassword, key));
RAS 非对称加密用法如下。

String input = "Java265.com是我最爱的网站，你知道吗?";
 
Map<String, byte[]> keyMap = generateKeyBytes();
 
// 加密
PublicKey publicKey = restorePublicKey(keyMap.get(PUBLIC_KEY));
byte[] encodedText = RSAEncode(publicKey, input.getBytes());
 
// 解密
 
PrivateKey privateKey = restorePrivateKey(keyMap.get(PRIVATE_KEY));
String decoded = RSADecode(privateKey, encodedText);
assertEquals(input, decoded);
下面是对称加密的工具类，完全可以不依赖其他三方 jar 包。不过有个 base64 方法我封装起来了（下面会补充）。

import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
 
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
 
import com.ajaxjs.util.Encode;
 
/**
 * 对称算法
 */
public class SymmetricCipher {
	public SymmetricCipher() {}
	public SymmetricCipher(String ALGORITHM, int keySize) {
		this.ALGORITHM = ALGORITHM;
		this.keySize = keySize;
	}
	/**
	 * DES = 56 | AES = 128
	 */
	private int keySize = 128;
 
	/**
	 * 加密算法，可以 DES | AES
	 */
	private String ALGORITHM = "AES";
	
	/**
	 * 加密
	 * 
	 * @param str
	 *            要加密的内容
	 * @param key
	 *            密钥
	 * @return 加密后的内容
	 */
	public String encrypt(String str, String key) {
		// 这里要设置为utf-8不然内容中如果有中文和英文混合中文就会解密为乱码
		return doCipher(true, key, str, str.getBytes(StandardCharsets.UTF_8));
	}
 
	/**
	 * 解密
	 * 
	 * @param str
	 *            要解密的内容
	 * @param key
	 *            密钥
	 * @return 解密后的内容
	 */
	public String decrypt(String str, String key) {
		return doCipher(false, key, str, Encode.base64DecodeAsByte(str));
	}
	
	private String doCipher(boolean isENCRYPT_MODE, String key, String str, byte[] bytes) {
		Cipher cipher = null;
		
		try {
			cipher = Cipher.getInstance(ALGORITHM);
			cipher.init(isENCRYPT_MODE ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, generateKey(key));
		} catch (NoSuchAlgorithmException | InvalidKeyException | NoSuchPaddingException e) {
			e.printStackTrace();
			return null;
		}
		
		byte[] buf;
		try {
			// 为了防止解密时报javax.crypto.IllegalBlockSizeException: Input length must
			// be multiple of 8 when decrypting with padded cipher异常，
			// 不能把加密后的字节数组直接转换成字符串
			buf = cipher.doFinal(bytes);
		} catch (IllegalBlockSizeException | BadPaddingException e) {
			e.printStackTrace();
			return null;
		}
		
		return isENCRYPT_MODE ? Encode.base64Encode(buf) : Encode.byte2String(buf);
	}
 
	/**
	 * 获得密钥对象
	 * 
	 * @param key
	 *            密钥
	 * @return 密钥对象
	 */
	private SecretKey generateKey(String key) {
		SecureRandom secureRandom;
		KeyGenerator kg;
		
		try {
			secureRandom = SecureRandom.getInstance("SHA1PRNG");
			secureRandom.setSeed(key.getBytes());
			kg = KeyGenerator.getInstance(ALGORITHM);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
			return null;
		}
		
		kg.init(keySize, secureRandom);
		return kg.generateKey();// 生成密钥
	}
	
	final static SymmetricCipher AES = new SymmetricCipher();
	final static SymmetricCipher DES = new SymmetricCipher("DES", 56);
 
	/**
	 * AES 加密
	 * 
	 * @param str
	 *            要加密的内容
	 * @param key
	 *            密钥
	 * @return 加密后的内容
	 */
	public static String AES_Encrypt(String str, String key) {
		return AES.encrypt(str, key);
	}
 
	/**
	 * AES 解密
	 * @param str
	 * @param key
	 * @return
	 */
	public static String AES_Decrypt(String str, String key) {
		return AES.decrypt(str, key);
	}
}

使用方法如下

import org.junit.Test;
import static org.junit.Assert.*;
 
import com.ajaxjs.user.password.SymmetricCipher;
 
public class TestPassword {
	String input = "uy45fd76dgty:908:234:8907432122";
	String key = "56y78ui905443d45g2cw098563ghj876";
	
	@Test
	public void testEncryption() {
		String EncryptedPassword = SymmetricCipher.AES_Encrypt(input, key);
//		System.out.println("EncryptedPassword::" +EncryptedPassword);
		
		assertEquals(input, SymmetricCipher.AES_Decrypt(EncryptedPassword, key));
	}
}