Java加解密算法技术

■一、加密算法说明

数据加密的基本过程就是对原来为明文的文件或数据按某种算法进行处理，使其成为不可读的一段代码为“密文”，使其只能在输入相应的密钥之后才能显示出原容，通过这样的途径来达到保护数据不被非法人窃取、阅读的目的。该过程的逆过程为解密，即将该编码信息转化为其原来数据的过程。

■二、常用加密算法(AES,RSA,MD5,Base64,SM3)

1)AES

高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传 输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥，具体的加密流程如下

2)RSA

RSA加密算法是一种典型的非对称加密算法，它基于大数的因式分解数学难题，它也是应用最广泛的非对称加密算法。
非对称加密是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。

※非对称加密算法流程图

※RSA加密算法流程图

3)MD5

MD5常常作为文件的签名出现，我们在下载文件的时候，常常会看到文件页面上附带一个扩展名为.MD5 的文本或者一行字符，这行字符就是就是把整个文件当作原数据通过MD5计算后的值，我们下载文件后，可以用检查文件MD5信息的软件对下载到的文件在进行一次计算。两次结果对比就可以确保下载到文件的准确性。另一种常见用途就是网站敏感信息加密，比如用户名密码，支付签名等等。随着https技术的普及，现在的网站广泛采用前台明文传输到后台，MD5加密(使用偏移量)的方式保护敏感数据保护站点和数据安全。

4)Base64

Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。

5)SM3

SM3算法适用于商用密码应用中的数字签名和验证、消息认证码的生成与验证以及随机数的生成，可满足多种密码应用的安全需求。SM3算法能够对任何小于264bit的数据进行计算，输出长度为256bit的Hash值。

■三、代码演示

1）AES

■一、AESUtils.java

package infosky.wdis.util.encryptionDecryption;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
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 javax.crypto.spec.SecretKeySpec;
import infosky.wdis.common.WdiConstants;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * AES对称加密和解密
 */
public class AESUtils {

	/**
	 * AES加密
	 * 1.构造密钥生成器
	 * 2.根据ecnodeRules规则初始化密钥生成器
	 * 3.产生密钥
	 * 4.创建和初始化密码器
	 * 5.内容加密
	 * 6.返回字符串
	 *
	 * @param encodeRules 加解密规则 ※简单理解为加解密Key
	 * @param content     加密内容
	 * @return
	 */
	public static String AESEncode(String encodeRules,String content){
		try {
			// 1.构造密钥生成器，指定为AES算法,不区分大小写
			KeyGenerator keygen=KeyGenerator.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_AES);
			// 2.根据ecnodeRules规则初始化密钥生成器
			// 生成一个128位的随机源,根据传入的字节数组
			keygen.init(128, new SecureRandom(encodeRules.getBytes()));
			// 3.产生原始对称密钥
			SecretKey original_key=keygen.generateKey();
			// 4.获得原始对称密钥的字节数组
			byte [] raw=original_key.getEncoded();
			// 5.根据字节数组生成AES密钥
			SecretKey key=new SecretKeySpec(raw, WdiConstants.ENCRYPTION_DECRYPTION_AES);
			// 6.根据指定算法AES自成密码器
			Cipher cipher=Cipher.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_AES);
			// 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
			cipher.init(Cipher.ENCRYPT_MODE, key);
			// 8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
			byte [] byte_encode=content.getBytes(WdiConstants.CHARSET_UTF_8);
			// 9.根据密码器的初始化方式--加密：将数据加密
			byte [] byte_AES=cipher.doFinal(byte_encode);
			// 10.将加密后的数据转换为字符串
			// 这里用Base64Encoder中会找不到包
			// 解决办法：
			// 在项目的Build path中先移除JRE System Library，再添加库JRE System Library，重新编译后就一切正常了。
			String AES_encode=new String(new BASE64Encoder().encode(byte_AES));
			//11.将字符串返回
			return AES_encode;
		} 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();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		// 如果有错就返加nulll
		return null;
	}

	/**
	 * AES解密
	 * 解密过程：
	 * 1.同加密1-4步
	 * 5.将加密后的字符串反纺成byte[]数组
	 * 6.将加密内容解密
	 *
	 * @param encodeRules 加解密规则 ※简单理解为加解密Key
	 * @param content     解密的内容
	 * @return
	 */
	public static String AESDncode(String encodeRules,String content){
		try {
			// 1.构造密钥生成器，指定为AES算法,不区分大小写
			KeyGenerator keygen=KeyGenerator.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_AES);
			// 2.根据ecnodeRules规则初始化密钥生成器
			// 生成一个128位的随机源,根据传入的字节数组
			keygen.init(128, new SecureRandom(encodeRules.getBytes()));
			// 3.产生原始对称密钥
			SecretKey original_key=keygen.generateKey();
			// 4.获得原始对称密钥的字节数组
			byte [] raw=original_key.getEncoded();
			// 5.根据字节数组生成AES密钥
			SecretKey key=new SecretKeySpec(raw, WdiConstants.ENCRYPTION_DECRYPTION_AES);
			//6.根据指定算法AES自成密码器
			Cipher cipher=Cipher.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_AES);
			// 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
			cipher.init(Cipher.DECRYPT_MODE, key);
			// 8.将加密并编码后的内容解码成字节数组
			byte [] byte_content= new BASE64Decoder().decodeBuffer(content);
			// 9.解密
			byte [] byte_decode=cipher.doFinal(byte_content);
			String AES_decode=new String(byte_decode,WdiConstants.CHARSET_UTF_8);
			return AES_decode;
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (NoSuchPaddingException e) {
			e.printStackTrace();
		} catch (InvalidKeyException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (IllegalBlockSizeException e) {
			e.printStackTrace();
		} catch (BadPaddingException e) {
			e.printStackTrace();
		}

		// 如果有错就返加nulll
		return null;
	}
}

2）RSA

■一、RSAUtils.java

package infosky.wdis.util.encryptionDecryption;
import infosky.wdis.common.WdiConstants;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * RSA非对称加解密
 */
public class RSAUtils {

	/**
	 * 随机生成密钥对
	 * ※一般可采用下面这组秘钥对
	 *   公钥:MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCBfKLuyiKWWXSLKEPaFG4oOMsKA4SdHUg19/bajtnINGQqBnxTVux9M58Hy+H2O8QbCTJYJGkMoqPQ88F8mnEklfJRXGFpgoxHmyG6AHuDn8nZjdTyGecZezY03jqe2Qt9d05fMTOsO52bQ2Iv4Wc/ek2tx1Henenx4Yyi+FJb5wIDAQAB
	 *   私钥:MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAIF8ou7KIpZZdIsoQ9oUbig4ywoDhJ0dSDX39tqO2cg0ZCoGfFNW7H0znwfL4fY7xBsJMlgkaQyio9DzwXyacSSV8lFcYWmCjEebIboAe4OfydmN1PIZ5xl7NjTeOp7ZC313Tl8xM6w7nZtDYi/hZz96Ta3HUd6d6fHhjKL4UlvnAgMBAAECgYAjs8/g807yEZw2ulVrDfMJmA8zpaCtCWPdrY8c2AJoVzm+9KbW+8KdCtywc6DMGdKKedCtyOxGFZoBhRQ2XQcQ3KTtpw8WNeZl6wEeyvmV8PO+/rEfH1kl6jVDPtYLO5/rd4/Y+7VKOZyRndOW8NJhqmV6AmfWG1Ei03cnwQxAMQJBAPPu0yyz8bVcFa1Ze+XHDRDxfRsE1AwrX2i0NwYuZuXjTKd6TY1duZd0rSjeeYKLQNLI/E6sTutQAPW65Cd5rdUCQQCH5HZzf9TzWIusAPE7bPZ6wrbp3zGgPvQGZHJaXfY/VNu7PTWou9MXqtqE3TzeD7nniZ4e4tAOh0RM5IrDTXTLAkEA0mtgxL4QseZWWKvJQcP8FHKL/cOjez/q1HIoyO88GfCCDjJlNZ30255tRMTswlyHNYzkgKUIitn/ifmGmDrRZQJASofbD23E9dJSiHvb0qPoa1vvxkVLin/8hqUAst9l90YrXX4st+aL2Cc0wjo07/XgGEU6G+Z6Bf3aT/HoyUTqEQJBALhckd/FQSFCstnCAkY9R+UCuaoo6JlQ6XOqkj82qkva/FVx9oJew5pKZ4KRaGgXVabct/uRsKvegv4AFTobAV4=
	 * @return
	 * @throws NoSuchAlgorithmException
	 */
	public static Map<Integer, String> genKeyPair() throws NoSuchAlgorithmException {
		// 用于封装随机产生的公钥与私钥
		Map<Integer, String> keyMap = new HashMap<Integer, String>();

		// KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_RSA);
		// 初始化密钥对生成器，密钥大小为96-1024位
		keyPairGen.initialize(1024,new SecureRandom());
		// 生成一个密钥对，保存在keyPair中
		KeyPair keyPair = keyPairGen.generateKeyPair();
		// 得到私钥
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
		// 得到公钥
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
		String publicKeyString = new String(Base64.encodeBase64(publicKey.getEncoded()));
		// 得到私钥字符串
		String privateKeyString = new String(Base64.encodeBase64((privateKey.getEncoded())));
		// 将公钥和私钥保存到Map ※0:公钥/1:私钥
		keyMap.put(0,publicKeyString);
		keyMap.put(1,privateKeyString);

		return keyMap;
	}

	/**
	 * RSA公钥加密
	 *
	 * @param str        加密字符串
	 * @param publicKey  公钥
	 * @return           密文
	 * @throws Exception 加密过程中的异常信息
	 */
	public static String encrypt( String str, String publicKey ) throws Exception{
		// base64编码的公钥
		byte[] decoded = Base64.decodeBase64(publicKey);
		RSAPublicKey pubKey = (RSAPublicKey) KeyFactory.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_RSA).
				generatePublic(new X509EncodedKeySpec(decoded));
		// RSA加密
		Cipher cipher = Cipher.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_RSA);
		cipher.init(Cipher.ENCRYPT_MODE, pubKey);
		String outStr = Base64.encodeBase64String(cipher.doFinal(str.getBytes(WdiConstants.CHARSET_UTF_8)));
		return outStr;
	}

	/**
	 * RSA私钥解密
	 *
	 * @param str        加密字符串
	 * @param privateKey 私钥
	 * @return           明文
	 * @throws Exception 解密过程中的异常信息
	 */
	public static String decrypt(String str, String privateKey) throws Exception{
		// 64位解码加密后的字符串
		byte[] inputByte = Base64.decodeBase64(str.getBytes(WdiConstants.CHARSET_UTF_8));
		// base64编码的私钥
		byte[] decoded = Base64.decodeBase64(privateKey);
		RSAPrivateKey priKey = (RSAPrivateKey) KeyFactory.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_RSA).
				generatePrivate(new PKCS8EncodedKeySpec(decoded));
		// RSA解密
		Cipher cipher = Cipher.getInstance(WdiConstants.ENCRYPTION_DECRYPTION_RSA);
		cipher.init(Cipher.DECRYPT_MODE, priKey);
		String outStr = new String(cipher.doFinal(inputByte));
		return outStr;
	}
}

3）MD5

■一、MD5Utils.java

package infosky.wdis.util.encryptionDecryption;
import java.security.MessageDigest;
import java.util.Random;

/**
 * MD5不可逆加密
 * ※本加密方法追加了加盐操作
 */
public class MD5Utils {

	/**
	 * byte[]字节数组 转换成 十六进制字符串
	 *
	 * @param arr 要转换的byte[]字节数组
	 * @return  String 返回十六进制字符串
	 */
	private static String hex(byte[] arr) {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < arr.length; ++i) {
			sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1, 3));
		}
		return sb.toString();
	}

	/**
	 * MD5加密,并把结果由字节数组转换成十六进制字符串
	 *
	 * @param str 要加密的内容
	 * @return String 返回加密后的十六进制字符串
	 */
	private static String md5Hex(String str) {
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			byte[] digest = md.digest(str.getBytes());
			return hex(digest);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(e.toString());
			return "";
		}
	}

	/**
	 * 生成含有随机盐的密码
	 *
	 * @param password 要加密的密码
	 * @return String 含有随机盐的密码
	 */
	public static String getSaltMD5(String password) {
		// 生成一个16位的随机数
		Random random = new Random();
		StringBuilder sBuilder = new StringBuilder(16);
		sBuilder.append(random.nextInt(99999999)).append(random.nextInt(99999999));
		int len = sBuilder.length();
		if (len < 16) {
			for (int i = 0; i < 16 - len; i++) {
				sBuilder.append("0");
			}
		}
		// 生成最终的加密盐
		String salt = sBuilder.toString();

		password = md5Hex(password + salt);
		char[] cs = new char[48];
		for (int i = 0; i < 48; i += 3) {
			cs[i] = password.charAt(i / 3 * 2);
			char c = salt.charAt(i / 3);
			cs[i + 1] = c;
			cs[i + 2] = password.charAt(i / 3 * 2 + 1);
		}
		return String.valueOf(cs);
	}

	/**
	 * 验证加盐后是否和原密码一致
	 *
	 * @param password 原密码
	 * @param password 加密之后的密码
	 *@return boolean true表示和原密码一致   false表示和原密码不一致
	 */
	public static boolean getSaltverifyMD5(String password, String md5str) {
		char[] cs1 = new char[32];
		char[] cs2 = new char[16];
		for (int i = 0; i < 48; i += 3) {
			cs1[i / 3 * 2] = md5str.charAt(i);
			cs1[i / 3 * 2 + 1] = md5str.charAt(i + 2);
			cs2[i / 3] = md5str.charAt(i + 1);
		}
		String Salt = new String(cs2);
		return md5Hex(password + Salt).equals(String.valueOf(cs1));
	}
}

4)Base64

■一、Base64Utils.java

package infosky.wdis.util.encryptionDecryption;
import infosky.wdis.common.WdiConstants;
import java.io.UnsupportedEncodingException;

/**
 * Base64对称加解密
 * ※Java8实现方式
 */
public class Base64Utils {

	/**
	 * 将字符串转换为Base64
	 *
	 * @param content 明文
	 * @return        密文
	 */
	public static String Base64Encode(String content){
		byte[] textByte = null;
		try {
			// 将字符串转换为2进制数字
			textByte = content.getBytes(WdiConstants.CHARSET_UTF_8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		// 转换Base64
		String result = WdiConstants.BASE64_ENCODER.encodeToString(textByte);
		return result;
	}

	/**
	 * 将Base64转换为字符串
	 * @param base64content 密文
	 * @return              明文
	 */
	public static String Base64Dncode(String base64content){
		String result = "";
		try {
			result = new String(WdiConstants.BASE64_DECODER.decode(base64content), WdiConstants.CHARSET_UTF_8);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return result;
	}
}

5)SM3

■一、SM3Utils.java

package infosky.wdis.util.encryptionDecryption;
import infosky.wdis.common.WdiConstants;
import org.bouncycastle.crypto.digests.SM3Digest;
import org.bouncycastle.crypto.macs.HMac;
import org.bouncycastle.crypto.params.KeyParameter;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;

/**
 * SM3加密算法
 */
public class SM3Utils {

	/**
	 * SM3加密(非密钥方式)
	 *
	 * @param content 待加密内容
	 * @return        加密结果(32位16进制字符串)
	 */
	public static String encrypt(String content){
		// 保存返回结果
		String resultHexString = "";
		try {
			// 将字符串转换为byte数组
			byte[] srcData = content.getBytes(WdiConstants.CHARSET_UTF_8);
			// 调用hash()
			byte[] resultHash = hash(srcData);
			// 将返回的hash值转换为16进制字符串
			resultHexString = ByteUtils.toHexString(resultHash);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return resultHexString;
	}

	/**
	 * 生产对应的hash值
	 *
	 * @param srcData byte数组
	 * @return        返回长度32的byte数组
	 */
	public static byte[] hash(byte[] srcData){
		SM3Digest sm3Digest = new SM3Digest();
		sm3Digest.update(srcData,0,srcData.length);
		byte[] hash = new byte[sm3Digest.getDigestSize()];
		sm3Digest.doFinal(hash,0);
		return hash;
	}

	/**
	 * SM3加密(密钥方式)
	 *
	 * @param content 待加密内容
	 * @param key     密钥
	 * @return
	 */
	public static String encryptByKey(String content,String key){
		// 保存返回结果
		String resultHexString = "";
		try {
			byte[] conData = content.getBytes(WdiConstants.CHARSET_UTF_8);
			byte[] keyData = key.getBytes(WdiConstants.CHARSET_UTF_8);
			KeyParameter keyParameter = new KeyParameter(keyData);
			SM3Digest sm3Digest = new SM3Digest();
			HMac hMac = new HMac(sm3Digest);
			hMac.init(keyParameter);
			hMac.update(conData,0,conData.length);
			byte[] result = new byte[hMac.getMacSize()];
			hMac.doFinal(result,0);
			resultHexString = ByteUtils.toHexString(result);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return resultHexString;
	}

	/**
	 * 判断加密前数据与加密数据是否一致
	 *
	 * @param content       待加密内容
	 * @param sm3HexContent 加密后结果
	 * @return
	 */
	public static boolean check(String content,String sm3HexContent) {
		boolean checkResult = false;
		try {
			byte[] conData = content.getBytes(WdiConstants.CHARSET_UTF_8);
			byte[] sm3HexConData = sm3HexContent.getBytes(WdiConstants.CHARSET_UTF_8);
			byte[] newHash = hash(conData);
			if(Arrays.equals(newHash,sm3HexConData)){
				checkResult = true;
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		return checkResult;
	}
}

※常数类

WdiConstants.java

package infosky.wdis.common;
import java.util.Base64;

/**
 * WEB数据交换业务常数类
 *
 * @author liutao
 */
public class WdiConstants {

    /** 接收发送地址最大值，对应接收发送表 */
    public static final int CONNECT_MAX = 20;

    /** 定时任务名称 */
    public static final String SYSTEM_TASK_BACKUPJOB = "SYSTEM_TASK_BACKUPJOB";

    /** 加解密-AES */
    public static final String ENCRYPTION_DECRYPTION_AES = "AES";

    /** 加解密-RSA */
    public static final String ENCRYPTION_DECRYPTION_RSA = "RSA";

    /** Base64-解密类 */
    public static final Base64.Decoder BASE64_DECODER = Base64.getDecoder();

    /** Base64-加密类 */
    public static final Base64.Encoder BASE64_ENCODER = Base64.getEncoder();

    /** UTF-8 */
    public static final String CHARSET_UTF_8 = "UTF-8";

    	/*
	 String     str
	 int        int
	 BigDecimal big
	 Long       log
	 float      flt
	 double     dob
	 boolean    bln
	 Date       dat
	 TimeZone   tzn
	 List       lst
	 Map        map
	 Set        set
	 */
}