数据安全这事儿，谁也绕不开。搞网络安全的，加密解密更是家常便饭。别再抱着教科书啃那些“高大上”的理论了！今天，咱就来聊聊几种常见的加密算法，保证让你看完之后，心里有数，手上有活儿。
1. 对称加密：速度是王道，但密钥管理是硬伤
对称加密，简单粗暴，一把钥匙开一把锁。加密解密用的是同一把密钥，速度那是杠杠的。但问题也来了：这钥匙怎么安全地送到对方手里？这才是最头疼的。
常见的对称加密算法，你得知道这几个：
AES（高级加密标准）：现在当红炸子鸡，安全性高，速度快，闭眼选它基本没错。DES（数据加密标准）：老古董了，安全性太低，现在基本没人用了。除非你还在维护上个世纪的系统。3DES（Triple DES）：DES的升级版，加密三次，安全性稍微高了点，但性能也下来了。Blowfish、Twofish：这两位比较灵活，各有千秋，具体场景具体分析。
优点？
速度快！数据量大的时候，优势明显。AES安全性够硬，用起来放心。
缺点？
密钥分发！这才是最大的坑，一不小心就被截胡了。密钥频繁更换的场景，不太适合。
实战场景：
硬盘加密：BitLocker、FileVault这些，保护你的小秘密。VPN、TLS/SSL：网络传输加密，防止被中间人偷窥。APP数据加密：配置文件、缓存数据，不想被人轻易看到？加密！
Java 代码示例？来点更接地气的注释！
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
public class AESDemo {
// 生成AES密钥，位数越高越安全，但也更慢
public static SecretKey generateAESKey(int n) throws Exception {
KeyGenerator keyGen = KeyGenerator.getInstance("AES");
keyGen.init(n); // 128, 192, or 256，一般128就够用了
return keyGen.generateKey();
}
// 加密
public static String encrypt(String data, SecretKey key) throws Exception {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encrypted = cipher.doFinal(data.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(encrypted); // Base64编码，方便传输
}
// 解密
public static String decrypt(String encryptedData, SecretKey key) throws Exception {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] decodedBytes = Base64.getDecoder().decode(encryptedData); // 先Base64解码
byte[] decrypted = cipher.doFinal(decodedBytes);
return new String(decrypted, "UTF-8");
}
public static void main(String[] args) throws Exception {
String originalText = "Hello, AES Encryption!";
SecretKey secretKey = generateAESKey(128);
String encryptedText = encrypt(originalText, secretKey);
System.out.println("Encrypted: " + encryptedText);
String decryptedText = decrypt(encryptedText, secretKey);
System.out.println("Decrypted: " + decryptedText);
}
}
2. 非对称加密：公钥加密，私钥解密，但性能是软肋
非对称加密，两把钥匙，公钥随便给人，私钥自己藏好。别人用你的公钥加密，只有你能用私钥解密。密钥分发的问题解决了，但速度嘛…呵呵。
常见的非对称加密算法：
RSA：应用最广泛，加密解密、数字签名都能干。ECC（椭圆曲线加密）：密钥短，效率高，移动设备上更受欢迎。DSA（数字签名算法）：专门用来做数字签名，保证数据没被篡改。
优点：
密钥分发安全！公钥随便发，不怕泄露。数字签名！能证明你的身份。
缺点：
速度慢！比对称加密慢多了。密钥长度有讲究，太短不安全，太长影响性能。
使用场景：
SSL/TLS：密钥交换，协商出一个对称密钥，后续就用对称加密了。数字签名：邮件签名、代码签名，证明身份，防止篡改。身份验证：PKI体系，验证用户身份。
Java 示例：RSA 加密解密，注意填充模式！
import java.security.*;
import javax.crypto.Cipher;
import java.util.Base64;
public class RSADemo {
// 生成RSA密钥对，密钥长度越高越安全，但性能越差
public static KeyPair generateRSAKeyPair(int keySize) throws NoSuchAlgorithmException {
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(keySize, new SecureRandom());
return keyGen.generateKeyPair();
}
// 使用RSA公钥加密
public static String encrypt(String data, PublicKey publicKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); // 使用OAEP填充，更安全
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] encryptedBytes = cipher.doFinal(data.getBytes("UTF-8"));
return Base64.getEncoder().encodeToString(encryptedBytes);
}
// 使用RSA私钥解密
public static String decrypt(String encryptedData, PrivateKey privateKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding"); // 使用OAEP填充，必须和加密时一致
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
return new String(decryptedBytes, "UTF-8");
}
public static void main(String[] args) {
try {
String originalText = "Hello, This is RSA Encryption!";
// 生成RSA密钥对
KeyPair keyPair = generateRSAKeyPair(2048);
// 加密
String encryptedText = encrypt(originalText, keyPair.getPublic());
System.out.println("Encrypted (RSA): " + encryptedText);
// 解密
String decryptedText = decrypt(encryptedText, keyPair.getPrivate());
System.out.println("Decrypted (RSA): " + decryptedText);
} catch (Exception e) {
e.printStackTrace();
}
}
}
注意： 别偷懒用 PKCS#1 填充，OAEP才是王道！
3. 哈希函数：单向加密，用于数据完整性校验
哈希函数，也叫散列函数，把任意长度的数据，变成固定长度的“指纹”。特点是：不可逆！也就是说，你没法从“指纹”反推出原始数据。主要用来验证数据有没有被篡改。
常见的哈希算法：
SHA-256、SHA-3：区块链、数据完整性校验，用得最多。MD5、SHA-1：老掉牙了，安全性不行，别用了！除非你真的没办法。
使用场景：
数据完整性校验：下载文件后，算个哈希值，和官方提供的比对一下，就知道有没有被动过手脚。密码存储：别直接存明文密码！哈希一下，再加个盐，安全多了。数字签名：先对数据哈希，再对哈希值签名，提高效率。
Java 示例：SHA-256，把数据变成一堆乱码！
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
public class SHADemo {
public static String hashSHA256(String data) throws NoSuchAlgorithmException {
MessageDigest digest = MessageDigest.getInstance("SHA-256");
byte[] hashBytes = digest.digest(data.getBytes());
// 转换为十六进制字符串
StringBuilder sb = new StringBuilder();
for (byte b : hashBytes) {
sb.append(String.format("%02x", b)); // 格式化成两位十六进制
}
return sb.toString();
}
public static void main(String[] args) throws Exception {
String originalText = "Hello, SHA-256 Hash!";
String hash = hashSHA256(originalText);
System.out.println("SHA-256 Hash: " + hash);
}
}
4. 量子加密：理论上绝对安全，但离实用还远着呢
量子加密，听起来就很科幻。利用量子力学的特性，保证密钥传输的绝对安全。就算你有量子计算机，也破解不了！
核心技术：量子密钥分发（QKD）
使用场景：
政府、军队、金融：对安全性要求最高的领域。未来网络安全：应对量子计算机的威胁。
Java 示例：BB84 协议模拟，感受一下量子纠缠的魅力（虽然是假的）
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
public class BB84Demo {
public static void main(String[] args) {
int keyLength = 100; // 初始密钥长度
double eavesdropProb = 0.05; // 窃听概率，即Eve拦截的比特比例
// Alice生成随机比特和基
List
List
// Eve可能窃听部分比特
List
List
Random rand = new Random();
for (int i = 0; i < keyLength; i++) {
if (rand.nextDouble() < eavesdropProb) {
// Eve窃听
char eBase = rand.nextBoolean() ? '+' : '×';
eavesdroppedBases.add(eBase);
// 如果Eve的基与Alice相同，Eve获取正确的比特；否则，Eve随机比特
if (eBase == aliceBases.get(i)) {
eavesdroppedBits.add(aliceBits.get(i));
} else {
eavesdroppedBits.add(rand.nextBoolean() ? 1 : 0);
}
} else {
eavesdroppedBits.add(null); // 没有窃听
}
}
// Bob接收量子比特，进行测量
List
List
for (int i = 0; i < keyLength; i++) {
char bBase = bobBases.get(i);
if (eavesdroppedBits.get(i) != null) {
// 如果Eve窃听了这个比特，Bob的测量可能受到影响
if (bBase == aliceBases.get(i)) {
bobBits.add(eavesdroppedBits.get(i));
} else {
bobBits.add(rand.nextBoolean() ? 1 : 0);
}
} else {
// 没有被窃听
if (bBase == aliceBases.get(i)) {
bobBits.add(aliceBits.get(i));
} else {
bobBits.add(rand.nextBoolean() ? 1 : 0);
}
}
}
// Alice和Bob公开基，保留基相同的比特
List
List
for (int i = 0; i < keyLength; i++) {
if (aliceBases.get(i).equals(bobBases.get(i))) {
aliceKey.add(aliceBits.get(i));
bobKey.add(bobBits.get(i));
}
}
System.out.println("Alice的初始比特序列: " + aliceBits);
System.out.println("Alice的基序列: " + aliceBases);
System.out.println("Bob的基序列: " + bobBases);
System.out.println("Eve窃听的比特序列: " + eavesdroppedBits);
System.out.println("Alice和Bob共享的密钥长度: " + aliceKey.size());
// 安全性检测：随机抽取部分密钥进行比对
int testSize = Math.min(10, aliceKey.size()); // 抽取10个比特进行测试
List
List
Random testRand = new Random();
List
while (indices.size() < testSize) {
int index = testRand.nextInt(aliceKey.size());
if (!indices.contains(index)) {
indices.add(index);
aliceTest.add(aliceKey.get(index));
bobTest.add(bobKey.get(index));
}
}
System.out.println("Alice的测试比特: " + aliceTest);
System.out.println("Bob的测试比特: " + bobTest);
// 计算错误率
int errorCount = 0;
for (int i = 0; i < testSize; i++) {
if (!aliceTest.get(i).equals(bobTest.get(i))) {
errorCount++;
}
}
double errorRate = (double) errorCount / testSize;
System.out.printf("测试错误率: %.2f%%
", errorRate * 100);
if (errorRate > 0.1) { // 假设错误率大于10%认为存在窃听
System.out.println("检测到潜在的窃听行为，放弃当前密钥并重新生成。");
} else {
// 移除测试比特后，剩余的密钥作为最终共享密钥
List
.collect(Collectors.toList());
for (int index : indices) {
finalKey.set(index, null);
}
finalKey = finalKey.stream().filter(bit -> bit != null).collect(Collectors.toList());
System.out.println("最终共享的密钥: " + finalKey);
}
}
// 生成随机比特序列
public static List
List
Random rand = new Random();
for (int i = 0; i < length; i++) {
bits.add(rand.nextBoolean() ? 1 : 0);
}
return bits;
}
// 生成随机基序列
public static List
List
Random rand = new Random();
for (int i = 0; i < length; i++) {
bases.add(rand.nextBoolean() ? '+' : '×');
}
return bases;
}
}
注意： 这只是个玩具，别当真！真正的量子加密可复杂多了。
5. 混合加密：鱼和熊掌兼得，速度和安全都要！
混合加密，就是把对称加密和非对称加密结合起来用。先用非对称加密协商出一个对称密钥，然后用对称加密来传输数据。
使用场景：
SSL/TLS：HTTPS背后的功臣。PGP：加密邮件、文件，保护你的隐私。
6. 总结：选哪个？看场景！
对称加密：速度快，适合大量数据加密，但密钥分发是个问题。非对称加密：密钥分发安全，但速度慢，适合少量数据加密或数字签名。哈希函数：用于数据完整性校验，不可逆。量子加密：理论上绝对安全，但离实用还远。混合加密：兼顾速度和安全，是主流选择。
记住，没有万能的加密算法，只有最适合你的。根据实际场景，选择合适的加密方式，才能真正保护你的数据安全！ ```
黑客/网络安全学习路线
今天只要你给我的文章点赞，我私藏的网安学习资料一样免费共享给你们，来看看有哪些东西。
网络安全学习资源分享:
下面给大家分享一份2025最新版的网络安全学习路线资料，帮助新人小白更系统、更快速的学习黑客技术！
一、2025最新网络安全学习路线
一个明确的学习路线可以帮助新人了解从哪里开始，按照什么顺序学习，以及需要掌握哪些知识点。
对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图&学习规划。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。
读者福利 | CSDN大礼包：《网络安全入门&进阶学习资源包》免费分享 （安全链接，放心点击）
我们把学习路线分成L1到L4四个阶段，一步步带你从入门到进阶，从理论到实战。

L1级别:网络安全的基础入门
L1阶段：我们会去了解计算机网络的基础知识，以及网络安全在行业的应用和分析；学习理解安全基础的核心原理，关键技术，以及PHP编程基础；通过证书考试，可以获得NISP/CISP。可就业安全运维工程师、等保测评工程师。

L2级别：网络安全的技术进阶
L2阶段我们会去学习渗透测试：包括情报收集、弱口令与口令爆破以及各大类型漏洞，还有漏洞挖掘和安全检查项目，可参加CISP-PTE证书考试。

L3级别：网络安全的高阶提升
L3阶段：我们会去学习反序列漏洞、RCE漏洞，也会学习到内网渗透实战、靶场实战和技术提取技术，系统学习Python编程和实战。参加CISP-PTE考试。

L4级别：网络安全的项目实战
L4阶段：我们会更加深入进行实战训练，包括代码审计、应急响应、红蓝对抗以及SRC的挖掘技术。并学习CTF夺旗赛的要点和刷题

整个网络安全学习路线L1主要是对计算机网络安全的理论基础的一个学习掌握；而L3 L4更多的是通过项目实战来掌握核心技术，针对以上网安的学习路线我们也整理了对应的学习视频教程，和配套的学习资料。
二、技术文档和经典PDF书籍
书籍和学习文档资料是学习网络安全过程中必不可少的，我自己整理技术文档，包括我参加大型网安行动、CTF和挖SRC漏洞的经验和技术要点，电子书也有200多本，（书籍含电子版PDF）

三、网络安全视频教程
对于很多自学或者没有基础的同学来说，书籍这些纯文字类的学习教材会觉得比较晦涩难以理解，因此，我们提供了丰富的网安视频教程，以动态、形象的方式展示技术概念，帮助你更快、更轻松地掌握核心知识。
网上虽然也有很多的学习资源，但基本上都残缺不全的，这是我自己录的网安视频教程，上面路线图的每一个知识点，我都有配套的视频讲解。

四、网络安全护网行动/CTF比赛
学以致用 ，当你的理论知识积累到一定程度，就需要通过项目实战，在实际操作中检验和巩固你所学到的知识，同时为你找工作和职业发展打下坚实的基础。

五、网络安全工具包、面试题和源码
“工欲善其事必先利其器”我为大家总结出了最受欢迎的几十款款黑客工具。涉及范围主要集中在 信息收集、Android黑客工具、自动化工具、网络钓鱼等，感兴趣的同学不容错过。 
面试不仅是技术的较量，更需要充分的准备。
在你已经掌握了技术之后，就需要开始准备面试，我们将提供精心整理的网安面试题库，涵盖当前面试中可能遇到的各种技术问题，让你在面试中游刃有余。
如果你是要找网安方面的工作，它们绝对能帮你大忙。
这些题目都是大家在面试深信服、奇安信、腾讯或者其它大厂面试时经常遇到的，如果大家有好的题目或者好的见解欢迎分享。
参考解析：深信服官网、奇安信官网、Freebuf、csdn等
内容特点：条理清晰，含图像化表示更加易懂。
内容概要：包括 内网、操作系统、协议、渗透测试、安服、漏洞、注入、XSS、CSRF、SSRF、文件上传、文件下载、文件包含、XXE、逻辑漏洞、工具、SQLmap、NMAP、BP、MSF…


**读者福利 |** CSDN大礼包：《网络安全入门&进阶学习资源包》免费分享 （安全链接，放心点击）