加密工具类

最新推荐文章于 2023-12-15 16:38:07 发布

图图小淘气_real

最新推荐文章于 2023-12-15 16:38:07 发布

阅读量184

点赞数

分类专栏： JAVA 前端

本文链接：https://blog.csdn.net/qq_41995919/article/details/100582254

版权

前端同时被 2 个专栏收录

73 篇文章 0 订阅

订阅专栏

JAVA

70 篇文章 1 订阅

订阅专栏

AES.java

package core.security;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
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.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * AES加密解密，并且编译成base64
 * 
 * @author
 *
 */
public class AES {
	private static byte[] ivKey = "cnooc20081234567".getBytes();
	private static final String encodeRules = "resafety";

	public AES() {
	}

	public static String decryptFromBase64(String src) {
		String result = null;
		try {
			result = decryptFromBase64(src, encodeRules);
		} catch (Exception e) {
			System.out.println(src);
			e.printStackTrace();
		}
		return result;
	}

	public static String encryptToBase64(String datasource) {
		return encryptToBase64(datasource, encodeRules);
	}

	public static String decryptFromBase64(String src, String key) throws Exception {
		BASE64Decoder decoder = new BASE64Decoder();
		byte[] result = decoder.decodeBuffer(src);
		byte[] decryResult = aesDecryptByBytes(result, key);
		return new String(decryResult, "UTF-8");
	}

	public static String encryptToBase64(String datasource, String key) {
		BASE64Encoder encoder = new BASE64Encoder();
		byte[] result = null;
		try {
			result = aesEncryptToBytes(datasource, key);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return encoder.encode(result);
	}

	/**
	 * 加密 1.构造密钥生成器 2.根据ecnodeRules规则初始化密钥生成器 3.产生密钥 4.创建和初始化密码器 5.内容加密 6.返回字符串
	 */
	public static String encodeAES(String content) {
		try {
			// 1.构造密钥生成器，指定为AES算法,不区分大小写
			KeyGenerator keygen = KeyGenerator.getInstance("AES");
			// 2.根据ecnodeRules规则初始化密钥生成器
			// 生成一个128位的随机源,根据传入的字节数组
			SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
			random.setSeed(encodeRules.getBytes());
			keygen.init(128, random);
			// 3.产生原始对称密钥
			SecretKey original_key = keygen.generateKey();
			// 4.获得原始对称密钥的字节数组
			byte[] raw = original_key.getEncoded();
			// 5.根据字节数组生成AES密钥
			SecretKey key = new SecretKeySpec(raw, "AES");
			// 6.根据指定算法AES自成密码器
			Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");//"算法/模式/补码方式"  
			IvParameterSpec iv = new IvParameterSpec(ivKey);//使用CBC模式，需要一个向量iv，可增加加密算法的强度
			// 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密解密(Decrypt_mode)操作，第二个参数为使用的KEY
			cipher.init(Cipher.ENCRYPT_MODE, key, iv);
			// 8.获取加密内容的字节数组(这里要设置为utf-8)不然内容中如果有中文和英文混合中文就会解密为乱码
			byte[] byte_encode = content.getBytes("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();
		} catch (InvalidAlgorithmParameterException e) {
			e.printStackTrace();
		}
		// 如果有错就返加nulll
		return null;
	}

	/**
	 * AES加密
	 * 
	 * @param content
	 *            待加密的内容
	 * @param encryptKey
	 *            加密密钥
	 * @return 加密后的byte[]
	 * @throws Exception
	 */
	public static byte[] aesEncryptToBytes(String content, String encryptKey) throws Exception {
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128, new SecureRandom(encryptKey.getBytes()));

		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");//"算法/模式/补码方式"  
		IvParameterSpec iv = new IvParameterSpec(ivKey);//使用CBC模式，需要一个向量iv，可增加加密算法的强度
		cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"), iv);

		return cipher.doFinal(content.getBytes("utf-8"));
	}

	/**
	 * 解密 解密过程： 1.同加密1-4步 2.将加密后的字符串反纺成byte[]数组 3.将加密内容解密
	 */
	public static String decodeAES(String content) {
		try {
			// 1.构造密钥生成器，指定为AES算法,不区分大小写
			KeyGenerator keygen = KeyGenerator.getInstance("AES");
			// 2.根据ecnodeRules规则初始化密钥生成器
			// 生成一个128位的随机源,根据传入的字节数组
			SecureRandom random = SecureRandom.getInstance("SHA1PRNG");
			random.setSeed(encodeRules.getBytes());
			keygen.init(128, random);
			// 3.产生原始对称密钥
			SecretKey original_key = keygen.generateKey();
			// 4.获得原始对称密钥的字节数组
			byte[] raw = original_key.getEncoded();
			// 5.根据字节数组生成AES密钥
			SecretKey key = new SecretKeySpec(raw, "AES");
			// 6.根据指定算法AES自成密码器
			Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");//"算法/模式/补码方式"  
			IvParameterSpec iv = new IvParameterSpec(ivKey);//使用CBC模式，需要一个向量iv，可增加加密算法的强度
			// 7.初始化密码器，第一个参数为加密(Encrypt_mode)或者解密(Decrypt_mode)操作，第二个参数为使用的KEY
			cipher.init(Cipher.DECRYPT_MODE, key, iv);
			// 8.将加密并编码后的内容解码成字节数组
			byte[] byte_content = new BASE64Decoder().decodeBuffer(content);
			/*
			 * 解密
			 */
			byte[] byte_decode = cipher.doFinal(byte_content);
			String AES_decode = new String(byte_decode, "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();
		} catch (InvalidAlgorithmParameterException e) {
			e.printStackTrace();
		}
		// 如果有错就返加nulll
		return null;
	}

	/**
	 * AES解密
	 * 
	 * @param encryptBytes
	 *            待解密的byte[]
	 * @param decryptKey
	 *            解密密钥
	 * @return 解密后的String
	 * @throws Exception
	 */
	public static byte[] aesDecryptByBytes(byte[] encryptBytes, String decryptKey) throws Exception {
		KeyGenerator kgen = KeyGenerator.getInstance("AES");
		kgen.init(128, new SecureRandom(decryptKey.getBytes()));

		Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");//"算法/模式/补码方式"  
		IvParameterSpec iv = new IvParameterSpec(ivKey);//使用CBC模式，需要一个向量iv，可增加加密算法的强度
		cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(kgen.generateKey().getEncoded(), "AES"), iv);
		return cipher.doFinal(encryptBytes);
	}

	// 测试
	/*public static void main(String args[]) throws IOException {
		// 待加密内容
		String str = "select * from t_r_user";
		// 密码，长度要是8的倍数
		String key = "96385214";
		// 密码，长度要是16的倍数
		//key = "9638521496385214";

		System.out.println("加密前：");
		System.out.println(str);
		System.out.println("秘钥为：");
		System.out.println(key);
		System.out.println("--------------------------------");

		String base64Result = encryptToBase64(str, key);
		System.out.println("加密再base64后：");
		System.out.println(base64Result);
		System.out.println("--------------------------------");

		// 直接将如上内容解密
		try {
			System.out.println("base64转字节再解密后：");
			System.out.println(decryptFromBase64(base64Result, key));
			System.out.println("--------------------------------");

			String rootkey = "test";
			System.out.println("加密之前的字符串:" + rootkey);
			String s = encodeAES(rootkey);
			System.out.println("加密之后形成的字符串" + s + "  长度:" + s.length());
			String s1 = decodeAES(s);
			System.out.println("解密之后的结果:" + s1);
		} catch (Exception e1) {
			e1.printStackTrace();
		}

	}*/

}

BASE64.java

package core.security;

import java.io.IOException;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class BASE64 {
	private static BASE64Encoder encoder = new BASE64Encoder();
	private static BASE64Decoder decoder = new BASE64Decoder();
	
	
	public static String encode( String datasource ) {
		return encoder.encode( datasource.getBytes() );
	}
	
	public static String decode( String base64 ) throws IOException {
		byte[] b = decoder.decodeBuffer( base64 );
		return new String( b );
	}
	
	public static void main( String[] args ) throws IOException {
		System.out.println( decode( encode("测试内容") )  );
		System.out.println( encode("测试内容")  );
	}

}

DES.java

package core.security;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.SecureRandom;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.SecretKeyFactory;
import javax.crypto.SecretKey;
import javax.crypto.Cipher;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * DES加密解密，并且编译成base64
 * 
 * @author 
 *
 */
public class DES {
	private static String password = "9D3e5E1p";


	public DES() {
	}


	public static String decryptFromBase64( String src ) {
		String result = null;
		try {
			result = decryptFromBase64( src, password );;
		}
		catch ( Exception e ) {
			System.out.println( src );
			e.printStackTrace();
		}
		
		return result;
	}


	public static String encryptToBase64( String datasource ) {
		return encryptToBase64( datasource, password );
	}


	public static String decryptFromBase64( String src, String password ) throws Exception {
		BASE64Decoder decoder = new BASE64Decoder();
		byte[] result = decoder.decodeBuffer( src );
		byte[] decryResult = decrypt( result, password );
		return new String( decryResult, "UTF-8" );
	}


	public static String encryptToBase64( String datasource, String password ) {
		BASE64Encoder encoder = new BASE64Encoder();
		byte[] result = encrypt( datasource.getBytes(), password );
		return encoder.encode( result );
	}


	/**
	 * 加密
	 * 
	 * @param datasource
	 *            byte[]
	 * @param password
	 *            String
	 * @return byte[]
	 */
	public static byte[] encrypt( byte[] datasource, String password ) {
		try {
			SecureRandom random = new SecureRandom();
			DESKeySpec desKey = new DESKeySpec( password.getBytes() );
			// 创建一个密匙工厂，然后用它把DESKeySpec转换成
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );
			SecretKey securekey = keyFactory.generateSecret( desKey );
			// Cipher对象实际完成加密操作
			Cipher cipher = Cipher.getInstance( "DES/ECB/PKCS5Padding" );
			// 用密匙初始化Cipher对象
			cipher.init( Cipher.ENCRYPT_MODE, securekey, random );
			// 现在，获取数据并加密
			// 正式执行加密操作
			return cipher.doFinal( datasource );
		}
		catch ( Throwable e ) {
			e.printStackTrace();
		}
		return null;
	}


	/**
	 * 解密
	 * 
	 * @param src
	 *            byte[]
	 * @param password
	 *            String
	 * @return byte[]
	 * @throws Exception
	 */
	public static byte[] decrypt( byte[] src, String password ) throws Exception {
		// DES算法要求有一个可信任的随机数源
		SecureRandom random = new SecureRandom();
		// 创建一个DESKeySpec对象
		DESKeySpec desKey = new DESKeySpec( password.getBytes() );
		// 创建一个密匙工厂
		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance( "DES" );
		// 将DESKeySpec对象转换成SecretKey对象
		SecretKey securekey = keyFactory.generateSecret( desKey );
		// Cipher对象实际完成解密操作
		Cipher cipher = Cipher.getInstance( "DES/ECB/PKCS5Padding" );
		// 用密匙初始化Cipher对象
		cipher.init( Cipher.DECRYPT_MODE, securekey, random );
		// 真正开始解密操作
		return cipher.doFinal( src );
	}
	
	
	

	// 测试
	public static void main( String args[] ) throws IOException {
		// 待加密内容
		String str = "select * from t_r_user";
		// 密码，长度要是8的倍数
		String password = "96385214";

		System.out.println("加密前：");
		System.out.println(str);
		System.out.println("秘钥为：");
		System.out.println(password);
		System.out.println("--------------------------------");

        //byte[] result = DES.encrypt( str.getBytes(), password );
        //System.out.println( "加密后：" + new String( result ) );
		
		String base64Result = encryptToBase64(str, password);
		System.out.println("加密再base64后：");
		System.out.println(base64Result);
		System.out.println("--------------------------------");
		
		// 直接将如上内容解密
		try {
            //byte[] decryResult = DES.decrypt( base64ResultByte, password );
            //System.out.println( "解密后：" + new String( decryResult ) );
			System.out.println( "base64转字节再解密后：" );
			System.out.println( decryptFromBase64(base64Result, password) );
			System.out.println("--------------------------------");
		}
		catch ( Exception e1 ) {
			e1.printStackTrace();
		}
		
		
	}
	
}

图图小淘气_real

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
加密工具类

AES.javapackage core.security;import java.io.IOException;import java.io.UnsupportedEncodingException;import java.security.InvalidAlgorithmParameterException;import java.security.InvalidKeyExcept...
复制链接

扫一扫