常用加密算法
加密算法分类
加密算法按是否可逆分为单向加密和双向加密。
单向加密
单向加密是不可逆的，也就是说只能进行加密，不能进行解密。通常用来传输或者存储敏感数据，如用户名、密码等。单向加密原则上不可破解，网络上所谓的破解实际上都属于碰撞，就是把常见的明文进行加密成密文后将明文和密文存储起来，然后逆向查询得到明文。常见的单向加密算法有MD5和SHA等。
双向加密
双向加密又称为可逆加密，分为对称加密和非对称加密。
对称加密
对称加密指加密和解密采用相同的密钥进行加解密的算法。对称加密的优点在于加解密的速度快和破解难度和密钥长度正相关。常见的对称加密算法：DES、3DES、IDEA、RC4、RC5、RC6、AES等。
非对称加密
非对称加密指加密和解密使用不同的密钥进行加解密的算法，因此也称为公私钥加密。假设两个用户要加密交换数据，双方交换公钥，使用时一方用对方的公钥加密，另一方即可用自己的私钥解密。非对称加密可以用来进行加解密，也可以用来进行加签和验签。常见的非对称加密算法：RSA、 DSA、 ECC等。
另外提一点：加密和解密都是配对密钥进行的，可以公钥加密私钥解密，也可以私钥加密公钥解密。但是为了安全，通常都是以对方的公钥加密，自持私钥解密。
对称加密和非对称比较
对称加密密钥管理比较难，不适合互联网，一般用于内部系统，安全性一般，加密速度快。
非对称加密密钥管理简单，安全性高，加密速度慢，适合小数据量的数据加密和数据签名。
以下为RSA加密算法工具类，仅供参考：
package com.huatech.common.util;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
/**
* 工具类
*/
public class RSAUtil {
/**
* 读取秘钥数据
* @param keyFilePath
* @return
*/
public static byte[] readKeyDatas(String keyFilePath){
BufferedReader bufferedReader=null;
try{
bufferedReader = new BufferedReader(new FileReader(keyFilePath));
String str=null;
StringBuilder stringBuilder=new StringBuilder();
while ((str=bufferedReader.readLine())!=null){
if(str.contains("---")){
continue;
}
stringBuilder.append(str);
}
return stringBuilder.toString().getBytes();
}catch (IOException e) {
e.printStackTrace();
}finally {
try {
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
/**
* 读取公钥
* @param publicKeyPath
* @return
*/
public static PublicKey getPublicKey(String publicKeyPath){
//1.读取公钥文件,获取公钥数据
byte[] bytesPublicBase64 = readKeyDatas(publicKeyPath);
//2.对读取回来的数据进行Base64解码
byte[] bytesPublic = Base64.getDecoder().decode(bytesPublicBase64);
//3.把解码后的数据,重新封装成一个PublicKey对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytesPublic);
KeyFactory keyFactory=null;
try {
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
}
return null;
}
/**
* 读取私钥
* @param privateKeyPath
* @return
*/
public static PrivateKey getPrivateKey(String privateKeyPath){
//1.读取私钥文件,获取私钥数据
byte[] bytesPrivateBase64 = readKeyDatas(privateKeyPath);
//2.对读取回来的数据进行Base64解码
byte[] bytesPrivate = Base64.getDecoder().decode(bytesPrivateBase64);
//3.把解码后的数据,重新封装成一个PrivateKey对象
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytesPrivate);
KeyFactory keyFactory=null;
try {
keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
}
return null;
}
/**
* 加密数据
* @param publicKey
* @param originData
* @return
*/
public static String encodeData(PublicKey publicKey,String originData){
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE,publicKey);
byte[] bytesEncrypt = cipher.doFinal(originData.getBytes());
//Base64编码
byte[] bytesEncryptBase64 = Base64.getEncoder().encode(bytesEncrypt);
return new String(bytesEncryptBase64);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return null;
}
/**
* 解密数据
* @param privateKey
* @param encodeData
* @return
*/
public static String decodeData(PrivateKey privateKey,String encodeData){
try {
//Base64解码
byte[] bytesEncrypt = Base64.getDecoder().decode(encodeData);
//加密
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] bytesDecrypt = cipher.doFinal(bytesEncrypt);
return new String(bytesDecrypt);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
}
return null;
}
/**
* 签名
* @param privateKey
* @param data
* @return
*/
public static byte[] signData(PrivateKey privateKey, String data){
byte[] signed = null;
Signature signature;
try {
signature = Signature.getInstance("Sha1WithRSA");
signature.initSign(privateKey);
signature.update(data.getBytes("UTF-8"));
signed = signature.sign();
} catch (NoSuchAlgorithmException e) {
} catch (InvalidKeyException e) {
} catch (SignatureException | UnsupportedEncodingException e) {
}
return signed;
}
/**
* 验签
* @param publicKey
* @param data
* @param signed
* @return
*/
public static boolean verifySign(PublicKey publicKey, String data, byte[] signed){
boolean verify = false;
Signature signature2;
try {
signature2 = Signature.getInstance("Sha1WithRSA");
signature2.initVerify(publicKey);
signature2.update(data.getBytes("UTF-8"));
verify = signature2.verify(signed);
} catch (NoSuchAlgorithmException e) {
} catch (InvalidKeyException e) {
} catch (SignatureException | UnsupportedEncodingException e) {
}
return verify;
}
}