加密工具类

1、BASE64：

public class BASE64Util
{
	/**
	 * Base64编码
	 * @param src
	 * @return
	 */
	public static String encode(String src)
	{
		try
		{
			BASE64Encoder encoder = new BASE64Encoder();
			byte[] bytes = src.getBytes("utf-8");
			String dest = encoder.encode(bytes);
			return dest;
		}
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 转换字节数组转换为BASE64编码内容
	 * @param bytes
	 * @return
	 */
	public static String encode(byte[] bytes)
	{
		try
		{
			BASE64Encoder encoder = new BASE64Encoder();
			String dest = encoder.encode(bytes);
			return dest;
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * Base64解码
	 * @param dest
	 * @return
	 */
	public static String decode(String dest)
	{
		try
		{
			BASE64Decoder decoder = new BASE64Decoder();
			byte[] decodeBytes = decoder.decodeBuffer(dest);
			return new String(decodeBytes,"UTF-8");
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		
		return null;
	}
	
	public static byte[] decodeToBytes(String dest)
	{
		try
		{
			BASE64Decoder decoder = new BASE64Decoder();
			byte[] decodeBytes = decoder.decodeBuffer(dest);
			return decodeBytes;
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		
		return null;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		
		String src = "Hello";
		String dest = BASE64Util.encode(src);
		System.out.println("编码后的内容: "+dest);
		System.out.println("解码后的内容: "+BASE64Util.decode(dest));
		
	}

}

2、MD5：

方法一：

public class Md5Util {


  public static String md5(String targetStr) {
    
	  //如果待加密的数据为空，就直接返回
	  if (targetStr == null||targetStr.equals("")) {
		  return "";
	  }
	  
	  //加密后的结果
      String value = "";
      //md5算法
      MessageDigest md5 = null;
      //缓存加密过程的数据
      StringBuffer buf = new StringBuffer("");
      
      try {
    	//获取MD5加密算法
        md5 = MessageDigest.getInstance("MD5");
        md5.update(targetStr.getBytes("utf-8"));
        byte[] b = md5.digest();

        int temp;
        for (int n = 0; n < b.length; n++) {
          temp = b[n];
          if (temp < 0){temp += 256;}
          if (temp < 16){buf.append("0");}
          buf.append(Integer.toHexString(temp));
        }
        
      } catch (Exception e) {
    	  e.printStackTrace();
      }
      
      //把缓存数据转化为字符串且转化为大写
      try {
    	  value = buf.toString().toUpperCase();
      } catch (Exception ex) {
    	  ex.printStackTrace();
      }
      
      return value;
  }
  
  public static void main(String[] args){
	  System.out.println(Md5Util.md5("Hello"));
  }
}

方法二：

/**
 * 
 * 传入参数：一个字节数组 传出参数：字节数组的 MD5 结果字符串
 */
public final class MD5 {

	public static String getMD5(String source) {
		return getMD5(source.getBytes());
	}

	public static String getMD5(byte[] source) {
		String s = null;
		char hexDigits[] = { // 用来将字节转换成 16 进制表示的字符
		'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		try {
			MessageDigest md = MessageDigest.getInstance("MD5");
			md.update(source);
			byte tmp[] = md.digest(); // MD5 的计算结果是一个 128 位的长整数，
			// 用字节表示就是 16 个字节
			char str[] = new char[16 * 2]; // 每个字节用 16 进制表示的话，使用两个字符，
			// 所以表示成 16 进制需要 32 个字符
			int k = 0; // 表示转换结果中对应的字符位置
			for (int i = 0; i < 16; i++) { // 从第一个字节开始，对 MD5 的每一个字节
				// 转换成 16 进制字符的转换
				byte byte0 = tmp[i]; // 取第 i 个字节
				str[k++] = hexDigits[byte0 >>> 4 & 0xf]; // 取字节中高 4 位的数字转换,
				// >>> 为逻辑右移，将符号位一起右移
				str[k++] = hexDigits[byte0 & 0xf]; // 取字节中低 4 位的数字转换
			}
			s = new String(str); // 换后的结果转换为字符串
		} catch (Exception e) {
			// e.printStackTrace();
		}
		return s;
	}

	public static String getMD5Short(String source) {

		return getMD5(source).substring(8, 24);

	}
}

3、DES加密：

public class DESUtil
{
	private static final String ALGORITHM = "DES";
	/**
	 * 初始化生成密钥
	 * @return
	 */
	private static String initKey(String seed)
	{
		try
		{
			SecureRandom random = null;
			if (seed != null)
			{
			 random = new SecureRandom(seed.getBytes());
			}
			else
			{
			 random = new SecureRandom();
			}
			
			// 初始化密钥生成器
			KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
			keyGenerator.init(random);
			
			SecretKey key = keyGenerator.generateKey();
			
			// 获取密钥二进制字节数组
			byte[] keyBytes = key.getEncoded();
			
			// 转换为Base64编码内容
			
			return BASE64Util.encode(keyBytes);
		}
		catch (NoSuchAlgorithmException e)
		{
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 加密的内容
	 * @param src
	 * @return
	 */
	public static String encrypt(String src,String keyString)
	{
		try
		{
			// 获取密钥 - Key应该是Base64编码后的密钥的字符串
			// 把字符串转换为密钥对象
			Key key = getKey(keyString);
			
			Cipher cipher = Cipher.getInstance(ALGORITHM);
			
			cipher.init(Cipher.ENCRYPT_MODE, key);
			
			byte[] bytes = cipher.doFinal(src.getBytes("UTF-8"));
			
			return BASE64Util.encode(bytes);
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 解密
	 * @param dest - Base64编码的加密数据
	 * @param keyString
	 * @return
	 */
	public static String decrypt(String dest,String keyString)
	{
		try
		{
			Key key = getKey(keyString);
			
			Cipher cipher = Cipher.getInstance(ALGORITHM);
			
			cipher.init(Cipher.DECRYPT_MODE, key);
			
			// 解码加密的dest
			//String destString = BASE64Util.decode(dest);
			//byte[] decryptBytes = cipher.doFinal(destString.getBytes("UTF-8"));
			
			// 把加密数据的Base64串进行解码，转换为字节数组
			byte[] bytes = BASE64Util.decodeToBytes(dest);
			
			// 明文的字节数组
			byte[] decryptBytes = cipher.doFinal(bytes);
			
			return new String(decryptBytes,"UTF-8");
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}
		return null;
	}
	
	/**
	 * 通过密钥字符串生成 密钥Key
	 * @param keyString - Base64编码后的内容
	 * @return
	 */
	private static Key getKey(String keyString)
	{
		try
		{
			String key = BASE64Util.decode(keyString);
			DESKeySpec keySpec = new DESKeySpec(key.getBytes("UTF-8"));
			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
			Key secretKey = keyFactory.generateSecret(keySpec);
			return secretKey;
		}
		catch (NoSuchAlgorithmException e)
		{
			e.printStackTrace();
		}
		catch (InvalidKeyException e)
		{
			e.printStackTrace();
		}
		catch (UnsupportedEncodingException e)
		{
			e.printStackTrace();
		}
		catch (InvalidKeySpecException e)
		{
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args)
	{
		// key
		// data
		// mode
		
		// 生成密钥
		String key = DESUtil.initKey("hello");
		
		System.out.println("密钥："+ key);
		
		// 密钥生成后，需要公布出去，加密和解密方都保存这个密钥
		
		String src = "hellohellohello";
				
		// 加密处理
		String dest = DESUtil.encrypt(src, key);
		System.out.println("加密的内容："+dest);
		
		// dest就要传输出去
		
		// 解密处理
		String decryptString = DESUtil.decrypt(dest, key);
		System.out.println("解密的内容："+decryptString);
		
	}

}

4、RSA加密：

public class RSAUtil
{
	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";

	/**
	 * 用私钥对信息生成数字签名
	 * 
	 * @param data
	 *          加密数据
	 * @param privateKey
	 *          私钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static String sign(String data, String privateKey) throws Exception
	{
		byte[] dataBytes = BASE64Util.decodeToBytes(data);
		
		// 解密由base64编码的私钥
		byte[] keyBytes = BASE64Util.decodeToBytes(privateKey);

		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取私钥匙对象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 用私钥对信息生成数字签名 MD5withRSA - 签名的内容进行了MD5处理
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		// 使用签名对象初始化私钥
		signature.initSign(priKey);
		// 加密后的内容
		signature.update(dataBytes);

		// signature.sign() - 签名后的内容 获取的是一个字节数组
		// MD5withRSA
		// 签名的内容 = Md5(RAS(明文内容))
		return BASE64Util.encode(signature.sign());
	}

	/**
	 * 校验数字签名
	 * 
	 * @param data
	 *          加密数据
	 * @param publicKey
	 *          公钥
	 * @param sign
	 *          数字签名
	 * 
	 * @return 校验成功返回true 失败返回false
	 * @throws Exception
	 * 
	 */
	public static boolean verify(String data, String publicKey, String sign)
			throws Exception
	{
		// 解密由base64编码的公钥
		byte[] keyBytes = BASE64Util.decodeToBytes(publicKey);
		
		// 
		byte[] dataBytes = BASE64Util.decodeToBytes(data);

		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		// 取公钥匙对象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);

		// 获取签名对象
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		
		// 设置公钥
		signature.initVerify(pubKey);
		
		// 通过数据更新签名
		signature.update(dataBytes);
		
		// 解码签名内容
		byte[] signDataBytes = BASE64Util.decodeToBytes(sign);

		// 验证签名是否正常
		// signDataBytes = Md5(RAS(明文内容))
		// data - RAS(明文内容)
		// verify方法 - MD5(data) == signDataBytes
		return signature.verify(signDataBytes);
	}
	
	/**
	 * 加密<br>
	 * 用公钥加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPublicKey(byte[] data, String key)
			throws Exception
	{
		// 对公钥解密
		byte[] keyBytes = BASE64Util.decodeToBytes(key);

		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);

		// 加密内容的字节数组
		return cipher.doFinal(data);
	}

	/**
	 * 解密<br>
	 * 用公钥解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPublicKey(byte[] data, String key)
			throws Exception
	{
		// 对密钥解密
		byte[] keyBytes = BASE64Util.decodeToBytes(key);

		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		
		// 获取公钥
		Key publicKey = keyFactory.generatePublic(x509KeySpec);

		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		
		// 设置加密类型，设置公钥
		cipher.init(Cipher.DECRYPT_MODE, publicKey);

		// 返回的结果是，明文字节内容
		return cipher.doFinal(data);
	}

	/**
	 * 加密<br>
	 * 用私钥加密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] encryptByPrivateKey(byte[] data, String key)
			throws Exception
	{
		// 对密钥解密
		byte[] keyBytes = BASE64Util.decodeToBytes(key);

		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		
		// 设置加密类型，设置私钥
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		// 加密内容的字节数组
		return cipher.doFinal(data);
	}
	
	/**
	 * 解密<br>
	 * 用私钥解密
	 * 
	 * @param data
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptByPrivateKey(byte[] data, String key)
			throws Exception
	{
		// 对密钥解密
		byte[] keyBytes = BASE64Util.decodeToBytes(key);

		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);

		return cipher.doFinal(data);
	}

	/**
	 * 取得私钥
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPrivateKey(Map<String, Object> keyMap)
			throws Exception
	{
		Key key = (Key) keyMap.get(PRIVATE_KEY);

		return BASE64Util.encode(key.getEncoded());
	}

	/**
	 * 取得公钥
	 * 
	 * @param keyMap
	 * @return
	 * @throws Exception
	 */
	public static String getPublicKey(Map<String, Object> keyMap)
			throws Exception
	{
		Key key = (Key) keyMap.get(PUBLIC_KEY);

		return BASE64Util.encode(key.getEncoded());
	}

	/**
	 * 初始化密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception
	{
		// 通过算法类型获得对应的密钥生成器
		KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
		// 指定密钥对的长度
		keyPairGen.initialize(1024);

		// 获取密钥对
		KeyPair keyPair = keyPairGen.generateKeyPair();

		// 公钥
		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

		// 私钥，进行了PKCS8编码
		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

		Map<String, Object> keyMap = new HashMap<String, Object>(2);

		keyMap.put(PUBLIC_KEY, publicKey);
		keyMap.put(PRIVATE_KEY, privateKey);
		
		return keyMap;
	}

	public static void main(String[] args) throws Exception
	{
		// 构建密钥对，私钥和公钥
		Map<String, Object> keyMap = RSAUtil.initKey();

		// 获取公钥
		String publicKey = RSAUtil.getPublicKey(keyMap);
		
		// 获取私钥
		String privateKey = RSAUtil.getPrivateKey(keyMap);
		
		System.err.println("公钥: \n\r" + publicKey);
		System.err.println("私钥： \n\r" + privateKey);
		
		// 1##############################
		System.err.println("\n私钥加密——公钥解密");
		String inputStr1 = "Android1515";
		byte[] data1 = inputStr1.getBytes();

		// 私钥加密
		byte[] encodedData1 = RSAUtil.encryptByPrivateKey(data1, privateKey);

		// 公钥解密，
		byte[] decodedData1 = RSAUtil.decryptByPublicKey(encodedData1, publicKey);

		String outputStr1 = new String(decodedData1,"UTF-8");
		
		// 把加密后的数据字节数组转换为base64格式
		String encryptData = BASE64Util.encode(encodedData1);
		
		System.err.println("加密内容: " + encryptData);
		
		System.err.println("加密前: " + inputStr1 + "\r" + "解密后: " + outputStr1);


		// 2##############################
		System.err.println("\n公钥加密——私钥解密");
		String inputStr = "加密内容加密内容加密内容加密内容加密内容加密内容";
		byte[] data = inputStr.getBytes();

		// 公钥加密
		byte[] encodedData = RSAUtil.encryptByPublicKey(data, publicKey);

		// 私钥解密
		byte[] decodedData = RSAUtil.decryptByPrivateKey(encodedData, privateKey);

		String outputStr = new String(decodedData);
		
		String encryptData2 = BASE64Util.encode(encodedData);
		
		System.err.println("加密内容: " + encryptData2);
		
		System.err.println("加密前: " + inputStr + "\r" + "解密后: " + outputStr);

		
		// 3##############################
		System.err.println("\n私钥签名——公钥验证签名");
		
		// 使用私钥产生签名
		// 数据应该是使用加密，使用公钥或者私钥加密
		
		//  encodedData1 - 已经加密的数据
		//  byte[] encodedData1 = RSAUtil.encryptByPrivateKey(data1, privateKey);
		//  把加密后的数据字节数组转换为base64格式
		//  String encryptData = BASE64Util.encode(encodedData1);
		
		String sign = RSAUtil.sign(encryptData, privateKey);
		System.err.println("签名:\r" + sign);

		// 网络传输中可能篡改
		//encodedData1[encodedData1.length - 1] = 10;
		encryptData = encryptData.replace('P', 'a');
		
		// 通过公钥验证签名
		// 第1个参数 - 加密内容的Base64编码内容
		// 第2个参数 - 公钥
		// 第3个参数 - 签名的内容
		boolean status = RSAUtil.verify(encryptData, publicKey, sign);
		System.err.println("是否为有效数据 : \r" + status);
		
		// 
	}
}

猜你喜欢