文章目录
- 一、对称加密算法AES
- 1. AES简介
- 2. AES代码
- 二、非对称加密RSA
- 1. RSA简介
- 2. 生成公钥私钥
- 3. RSA代码
一、对称加密算法AES
1. AES简介
对称加密算法AES是目前广泛使用的一种加密技术，它采用相同的密钥来进行数据的加密和解密。
AES的优点
- 高效性：AES在多种平台上都具有很好的性能，能够快速加密和解密数据。
- 安全性：AES被认为是一个非常安全的加密标准。
- 灵活性：支持多种密钥长度，可以根据不同的安全需求选择合适的密钥。
AES的注意事项
- 密钥管理：由于AES使用的是对称密钥，因此密钥的安全存储和分发至关重要。
- 填充方式：在加密过程中，需要对数据块进行填充以使其符合块大小要求，常用的填充方式有PKCS、CBC等。
- 初始化向量：在某些AES模式下，如CBC模式，需要使用IV来增加加密的随机性。
2. AES代码
import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
/**
* AES 加密和解密
*/
public class AesTest {
// 秘钥
private static String KEY = "aaccB1123Mopac31";
// 向量
private static String IV = "CdmccsaCCcdsADf";
/**
* 加密
* @param content 待加密内容
* */
public static String encrypt(String content) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
SecretKeySpec secretKeySpec = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8)));
return Base64.getEncoder().encodeToString(cipher.doFinal(content.getBytes(StandardCharsets.UTF_8)));
}
/**
* 解密
* @param content 加密内容
* */
public static String decrypt(String content) throws Exception {
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
SecretKeySpec secretKeySpec = new SecretKeySpec(KEY.getBytes(StandardCharsets.UTF_8), "AES");
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(IV.getBytes(StandardCharsets.UTF_8)));
byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(content));
return new String(decryptedBytes, StandardCharsets.UTF_8);
}
public static void main(String[] args) throws Exception {
String text = "加密内容";
String encryptText = encrypt(text);
System.out.println("加密后内容：" + encryptText);
System.out.println("解密后内容：" + decrypt(encryptText));
}
}
- 效果
二、非对称加密RSA
1. RSA简介
RSA是一种非对称加密算法，使用一对公钥和私钥来进行加密和解密操作，公钥用于加密数据，私钥用于解密数据。
RSA的优点
- 安全性：RSA基于大数因子分解难题，被认为是一种非常安全的加密算法。
- 灵活性：RSA支持不同的密钥长度，可以根据需要选择适合的密钥长度来平衡安全性和性能。
- 数字签名：RSA算法可以用于生成和验证数字签名，提供数据的完整性和身份验证功能。
RSA的注意事项
- 密钥长度：选择合适的密钥长度非常重要，常见的密钥长度有1024位、2048位等，长度越长安全性越高。
- 安全存储：私钥需要严格保密，确保私钥不被泄露，否则将导致加密数据的泄露。
- 性能：RSA加密和解密的性能相对较低，需要注意在大量数据加密时可能会影响性能。
加密场景
- A生成一对密钥：公钥、私钥
- B使用公钥对消息进行加密
- A使用私钥对消息进行解密
验签场景
- A生成一对密钥：公钥、私钥
- A使用私钥对消息进行签名
- B使用私公钥对消息内容和消息签名进行验签
2. 生成公钥私钥
生成1024位的RSA私钥
openssl genrsa -out private.key 1024
使用私钥生成公钥
openssl rsa -in private.key -pubout -out public.key
使用公钥加密
openssl pkeyutl -encrypt -pubin -inkey public.key -in test.txt -out test.encrypt
使用私钥解密
openssl pkeyutl -decrypt -inkey private.key -in test.encrypt -out test.decrypt
使用私钥签名
openssl pkeyutl -sign -inkey private.key -in test.txt -out test.sign
使用公钥恢复签名数据
openssl pkeyutl -verifyrecover -pubin -inkey public.key -in test.sign -out test.verify
使用公钥验签
openssl pkeyutl -verify -in test.txt -sigfile test.sign -pubin -inkey public.key
3. RSA代码
import javax.crypto.Cipher;
import java.util.Base64;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* RSA 加密解密和签名验签
*/
public class RsaTest {
// 公钥
private static String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDHDYWXIMltI+zia0lrxm1dJu96" +
"QkogDVLsaFXxnjCZl72evCU0CAlWGDPc3gzJYFNw1KZvNRuTTiKbGa0enFc8hDoG" +
"Sjg37Na8OqMzLZZ/N6/DCAUywk1JNhMfYDr0GSYNgV37NXWvKD3rbvfxCkoH3ojn" +
"B3zUgr31VQfryzXq+QIDAQAB";
// 私钥
private static String PRIVATE_KEY = "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMcNhZcgyW0j7OJr" +
"SWvGbV0m73pCSiANUuxoVfGeMJmXvZ68JTQICVYYM9zeDMlgU3DUpm81G5NOIpsZ" +
"rR6cVzyEOgZKODfs1rw6ozMtln83r8MIBTLCTUk2Ex9gOvQZJg2BXfs1da8oPetu" +
"9/EKSgfeiOcHfNSCvfVVB+vLNer5AgMBAAECgYBNTSADJ9VxkBEPgRC7TQztrxAz" +
"T4kP13zLmF0//unqy/X0riZYhYJyr+V8MbOPhNwCpmKYL2ytERv5VchYaeiqRBsQ" +
"vVqVhz5oBGmVxyrHsfiRl4F+3vUA/qeewmNl/rFTxXBH5T3J0SzppSD6Z9+gdPiy" +
"wl51fut+FqggqbiH/QJBAP9ETAF+qKM5pW2KHhNbeKwxc2e0y3fvxAEfFKD6GakT" +
"d38QMTULN6kmZl3vhJXSxY/Xt8OjZVOvOTWj4yoqXycCQQDHn+O9viCin1HGtv1W" +
"LIMxYFIj3m+3CgE2RltgVErmxS5Jo3bh86UFk8t+/JRRhatpxKaPBlOzN4WsmbkW" +
"b7jfAkAWuTOy5l2Iujb5u1PWEUx6t6Q4VSXPtW5TUzr44YqrPGpky0I2IJuB2UM/" +
"lXTOCYdAuMlJByCcBHspRT+Rn1f9AkEAibZAqxXtd6KHDJoSXI9qlfaH09zQnqoV" +
"OfcBdIvR/C9NBlnxWmD1l8pkmR7vxul63gVejc5kkX8dBXwq1lKOawJBAKeVg9VB" +
"hj7WkjgoIVnuI8CIrO6IpboS+ySV/CZalkyNNVRWq2rOJbpIHe4baXqPomZ8mFEA" +
"4SGoEW3AiyFiqb8=";
/**
* 实例化公钥
* @param publicKey 公钥
*/
public static PublicKey getPublicKey(String publicKey) throws Exception {
byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey.getBytes());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(publicKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePublic(keySpec);
}
/**
* 实例化私钥
* @param privateKey 私钥
*/
public static PrivateKey getPrivateKey(String privateKey) throws Exception {
byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey.getBytes());
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return keyFactory.generatePrivate(keySpec);
}
/**
* 公钥加密
* @param content 待加密内容
*/
public static String encrypt(String content, String publicKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, getPublicKey(publicKey));
return new String(Base64.getEncoder().encode(cipher.doFinal(content.getBytes("UTF-8"))));
}
/**
* 私钥解密
* @param content 加密内容
*/
public static String decrypt(String content, String privateKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKey));
return new String(cipher.doFinal(Base64.getDecoder().decode(content)));
}
/**
* 私钥签名
* @param content 待签名内容
*/
public static String sign(String content, String privateKey) throws Exception {
Signature signature = Signature.getInstance("SHA1WithRSA");
signature.initSign(getPrivateKey(privateKey));
signature.update(content.getBytes("UTF-8"));
return new String(Base64.getEncoder().encode(signature.sign()));
}
/**
* 公钥验签
* @param content 原始内容
* @param sign 签名内容
*/
public static boolean verify(String content, String sign, String publicKey) throws Exception {
Signature signature = Signature.getInstance("SHA1WithRSA");
signature.initVerify(getPublicKey(publicKey));
signature.update(content.getBytes("UTF-8"));
return signature.verify(Base64.getDecoder().decode(sign));
}
public static void main(String[] args) throws Exception {
String content = "消息内容";
String encrypt = encrypt(content,PUBLIC_KEY);
System.out.println(encrypt);
String decryp = decrypt(encrypt,PRIVATE_KEY);
System.out.println(decryp);
String sign = sign(content,PRIVATE_KEY);
System.out.println(sign);
boolean verify = verify(content,sign,PUBLIC_KEY);
System.out.println(verify);
}
}
- 效果
