编程语言Node.jsjava算法
加密与编码算法详解：Java 与 JavaScript 实现
详细解析了加密与编码的核心概念，涵盖对称加密（AES-GCM）、非对称加密（RSA-OAEP）、数字签名（RSASSA-PSS）及密码哈希（PBKDF2）。通过对比 Java 与 JavaScript (Node.js) 的实战代码，演示了如何正确实现安全通信、密钥管理及身份验证，并分析了常见攻击与防御策略。
详细解析了加密与编码的核心概念，涵盖对称加密（AES-GCM）、非对称加密（RSA-OAEP）、数字签名（RSASSA-PSS）及密码哈希（PBKDF2）。通过对比 Java 与 JavaScript (Node.js) 的实战代码，演示了如何正确实现安全通信、密钥管理及身份验证，并分析了常见攻击与防御策略。
| 类型 | 功能 | 是否可逆 | 安全性 | 典型用途 |
|---|---|---|---|---|
| Base64 | 编码（非加密） | ✅ 可逆 | ❌ 无保密性 | 邮件、JWT、图片内嵌 |
| MD5 / SHA-1 | 哈希摘要 | ❌ 不可逆 | ⚠️ 已不安全 | 文件校验（仅限非敏感场景） |
| SHA-2 / SHA-3 | 哈希摘要 | ❌ 不可逆 | ✅ 安全 | 密码哈希、数字签名 |
| 对称加密（AES） | 加密 | ✅ 可逆 | ✅ 高（需正确使用） | 数据传输、数据库加密 |
| 非对称加密（RSA） | 加密/签名 | ✅ 可逆 | ✅ 高（需足够密钥长度） | 密钥交换、身份认证 |
关键区分：编码 ≠ 加密（Base64 是编码）哈希 ≠ 加密（MD5/SHA 是单向函数）加密必须可逆（否则无法还原数据）
AES (Advanced Encryption Standard) 是基于SP 网络（代换 - 置换网络）的。它是目前最流行的对称加密算法。
AES 加密不是一步完成的，而是需要多轮迭代（AES-128 为 10 轮）。下图展示了核心的数据处理流向：
输入：128 位明文块
AddRoundKey (与轮密钥异或)
SubBytes (S 盒替换)
ShiftRows (行移位)
MixColumns (列混合)
AddRoundKey (与轮密钥异或)
...
输出：128 位密文块
AES 只能处理 16 字节（128 位）的块。对于长数据，需要模式来切分。下图对比了不安全的 ECB 模式与安全的 CBC 模式：
CBC 模式 - 安全 异或 XOR -> AES 加密 -> 异或 XOR -> AES 加密 初始化向量 IV + 明文块 1 -> 密文 1 明文块 2 -> 密文 2
ECB 模式 - 不安全 AES 加密 -> AES 加密 明文块 1 -> 密文 1 明文块 1 -> 密文块 明文块 2 -> 密文 2
图解说明：ECB：相同的明文块（如 P1_1 和 P1_2）生成了完全相同的密文块，这会暴露数据的统计规律（例如加密一张黑白图片，轮廓依然可见）。CBC：引入了随机初始化向量（IV），并将上一个密文块参与到下一个块的加密中。即使明文相同，只要 IV 不同，密文就完全不同。
推荐使用 AES-GCM 模式，因为它不仅加密数据，还生成认证标签，防止篡改。
Java 标准库 javax.crypto 提供了完整的 AES-GCM 支持。
import javax.crypto.Cipher;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;
public class AesGcmExample {
private static final String AES_GCM_NO_PADDING = "AES/GCM/NoPadding";
private static final int GCM_TAG_LENGTH_BITS = 128; // 必须是 128, 120 或 112
private static final int GCM_IV_LENGTH_BYTES = 12; // 推荐长度 12 bytes
public static String encrypt(byte[] plaintext, byte[] key) throws Exception {
// 1. 生成随机 IV (Nonce)
byte[] iv = new byte[GCM_IV_LENGTH_BYTES];
new SecureRandom().nextBytes(iv);
// 2. 初始化 Cipher
SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH_BITS, iv);
Cipher cipher = Cipher.getInstance(AES_GCM_NO_PADDING);
cipher.init(Cipher.ENCRYPT_MODE, keySpec, gcmSpec);
// 3. 加密
byte[] ciphertext = cipher.doFinal(plaintext);
// 4. 拼接 IV 和 Ciphertext (IV 不需要保密，但必须和密文一起传输)
byte[] encryptedBytes = new byte[iv.length + ciphertext.length];
System.arraycopy(iv, 0, encryptedBytes, 0, iv.length);
System.arraycopy(ciphertext, 0, encryptedBytes, iv.length, ciphertext.length);
return Base64.getEncoder().encodeToString(encryptedBytes);
}
public static String decrypt(String encryptedStr, byte[] key) throws Exception {
// 1. 解码 Base64
byte[] encryptedBytes = Base64.getDecoder().decode(encryptedStr);
// 2. 分离 IV 和 Ciphertext
byte[] iv = new byte[GCM_IV_LENGTH_BYTES];
System.arraycopy(encryptedBytes, 0, iv, 0, iv.length);
byte[] ciphertext = new byte[encryptedBytes.length - GCM_IV_LENGTH_BYTES];
System.arraycopy(encryptedBytes, iv.length, ciphertext, 0, ciphertext.length);
// 3. 初始化 Cipher 解密
SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
GCMParameterSpec gcmSpec = new GCMParameterSpec(GCM_TAG_LENGTH_BITS, iv);
Cipher cipher = Cipher.getInstance(AES_GCM_NO_PADDING);
cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmSpec);
// 4. 解密 (如果被篡改，此处会抛出 AEADBadTagException)
byte[] plaintext = cipher.doFinal(ciphertext);
return new String(plaintext);
}
public static void main(String[] args) throws Exception {
byte[] key = new byte[32]; // AES-256 Key (在实际应用中请从 KMS 获取)
new SecureRandom().nextBytes(key);
String msg = "Top Secret Message";
String encrypted = encrypt(msg.getBytes(), key);
System.out.println("Encrypted: " + encrypted);
String decrypted = decrypt(encrypted, key);
System.out.println("Decrypted: " + decrypted);
}
}
Node.js 内置 crypto 模块处理 GCM 模式非常方便。
const crypto = require('crypto');
const ALGO_NAME = 'aes-256-gcm';
const IV_LENGTH = 12; // 12 bytes
const KEY_LENGTH = 32; // 32 bytes for AES-256
function encrypt(text, key) {
// 1. 生成随机 IV
const iv = crypto.randomBytes(IV_LENGTH);
// 2. 创建加密器
const cipher = crypto.createCipheriv(ALGO_NAME, key, iv);
// 3. 加密 (Buffer.concat 拼接)
let encrypted = cipher.update(text, 'utf8');
encrypted = Buffer.concat([encrypted, cipher.final()]);
// 4. 获取 Auth Tag (必须随密文发送)
const authTag = cipher.getAuthTag();
// 5. 返回：IV + AuthTag + Ciphertext (通常拼接后转 Base64)
return Buffer.concat([iv, authTag, encrypted]).toString('base64');
}
function decrypt(encryptedData, key) {
// 1. 解码 Base64
const buffer = Buffer.from(encryptedData, 'base64');
// 2. 提取 IV, AuthTag, Ciphertext
iv = buffer.(, );
authTag = buffer.(, + );
ciphertext = buffer.( + );
decipher = crypto.(, key, iv);
decipher.(authTag);
decrypted = decipher.(ciphertext);
decrypted = .([decrypted, decipher.()]);
decrypted.();
}
key = crypto.();
msg = ;
encrypted = (msg, key);
.(, encrypted);
decrypted = (encrypted, key);
.(, decrypted);
RSA 的安全性依赖于大整数分解难题。
下图展示了从选择质数到生成公私钥对的完整数学逻辑流程：
开始：生成密钥对
随机选择两个大质数 p, q
计算模数 n = p * q
计算欧拉函数 phi = p-1 * q-1
选择公钥指数 e (条件：1 < e < phi 且互质)
计算私钥指数 d (条件：e * d ≡ 1 mod phi)
生成结果：公钥 (n, e), 私钥 (n, d)
直接用 RSA 加密数据（教科书式 RSA）是极其危险的。必须使用填充。OAEP (Optimal Asymmetric Encryption Padding) 是目前的标准。
为何需要 OAEP？ 没有填充的 RSA 是确定性的（相同的明文永远得到相同的密文），且容易满足特定数学结构导致被破解。OAEP 引入了随机性，使加密变成概率性的。
注意：RSA 速度慢，通常只用来加密对称密钥，不直接加密大文件。
使用 RSA/ECB/OAEPWithSHA-256AndMGF1Padding。
import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.util.Base64;
public class RsaOaepExample {
public static void main(String[] args) throws Exception {
// 1. 生成 RSA 密钥对 (2048 位)
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048, new SecureRandom());
KeyPair keyPair = keyGen.generateKeyPair();
String message = "Here is the AES Key: 1234567890123456";
// 2. 加密 (使用公钥)
Cipher encryptCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
encryptCipher.init(Cipher.ENCRYPT_MODE, keyPair.getPublic());
byte[] encryptedBytes = encryptCipher.doFinal(message.getBytes());
System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encryptedBytes));
// 3. 解密 (使用私钥)
Cipher decryptCipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
decryptCipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
byte[] decryptedBytes = decryptCipher.doFinal(encryptedBytes);
System.out.println( + (decryptedBytes));
}
}
使用 crypto.publicEncrypt 和 oaepHash 选项。
const crypto = require('crypto');
// 1. 生成密钥对
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
modulusLength: 2048,
publicKeyEncoding: { type: 'spki', format: 'pem' },
privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});
const message = "Here is the AES Key: 1234567890123456";
// 2. 加密 (使用公钥)
const encrypted = crypto.publicEncrypt({
key: publicKey,
padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
oaepHash: "sha256" // 指定 OAEP 的 Hash 算法
}, Buffer.from(message));
console.log("Encrypted (len):", encrypted.length);
// 3. 解密 (使用私钥)
const decrypted = crypto.privateDecrypt({
key: privateKey,
padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
oaepHash: "sha256"
}, encrypted);
console.log("Decrypted:", decrypted.toString());
数字签名是'私钥加密哈希'的现代严谨说法（实际操作略有不同，常用 PSS 填充）。
下图展示了发送方如何使用私钥签名，接收方如何使用公钥验证身份和完整性：
发送方：
1. 准备数据
2. 计算原始消息的哈希值 Hash_A
3. 使用私钥加密 Hash_A 生成签名 Signature
4. 发送 [原始消息] + [数字签名]
接收方：
1. 计算收到消息的哈希值 Hash_B
2. 使用公钥解密签名 得到 Hash_A
3. 验证 Hash_A == Hash_B
✅ 验证通过 (数据完整且来源真实)
❌ 验证失败 (数据已篡改或来源伪造)
Java 11+ 和 Node.js 均原生支持 PSS 填充，这是比 PKCS#1 v1.5 更安全的签名方案。
import java.security.*;
import java.util.Base64;
public class RsaPssExample {
public static void main(String[] args) throws Exception {
// 1. 生成密钥对
KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048);
KeyPair keyPair = keyGen.generateKeyPair();
String message = "Important contract content";
// 2. 签名 (使用私钥)
Signature signature = Signature.getInstance("RSASSA-PSS");
signature.setParameter(new PSSParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, 32, 1));
signature.initSign(keyPair.getPrivate());
signature.update(message.getBytes());
byte[] signatureBytes = signature.sign();
System.out.println("Signature: " + Base64.getEncoder().encodeToString(signatureBytes));
// 3. 验证 (使用公钥)
Signature verifier = Signature.getInstance("RSASSA-PSS");
verifier.setParameter(new PSSParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, , ));
verifier.initVerify(keyPair.getPublic());
verifier.update(message.getBytes());
verifier.verify(signatureBytes);
System.out.println( + isValid);
}
}
const crypto = require('crypto');
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
modulusLength: 2048,
publicKeyEncoding: { type: 'spki', format: 'pem' },
privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
});
const message = "Important contract content";
// 1. 签名
const sign = crypto.createSign('sha256');
sign.update(message);
sign.end();
const signature = sign.sign({
key: privateKey,
padding: crypto.constants.RSA_PKCS1_PSS_PADDING,
saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST // 盐长度等于摘要长度
});
console.log("Signature (len):", signature.length);
// 2. 验证
const verify = crypto.createVerify('sha256');
verify.update(message);
verify.end();
const isValid = verify.verify({
key: publicKey,
padding: crypto.constants.,
: crypto..
}, signature);
.(, isValid);
这是现代互联网安全的基础，结合了非对称加密（交换密钥）和对称加密（传输数据）。
Server <-> Client
1. ClientHello (支持的加密套件，随机数 C)
2. ServerHello (选定加密套件，随机数 S)
3. Certificate (包含服务器公钥)
4. ServerHelloDone
5. 验证证书 & 生成预主密钥
6. [使用公钥加密] 预主密钥
7. [使用私钥解密] 得到预主密钥
8. 双方共同计算会话密钥 = PRF(随机数 C + 随机数 S + 预主密钥)
======== 建立安全通道 ========
9. ChangeCipherSpec 通知后续加密
10. Finished (使用会话密钥加密的校验消息)
11. ChangeCipherSpec
12. Finished
[使用 AES/会话密钥] 加密的应用数据
注：TLS 1.3 对此进行了优化，移除了 RSA 密钥交换，强制使用 ECDHE，仅需 1-RTT（往返延迟）。
作为开发者，你可以使用命令行工具验证上述流程（无论你用 Java 还是 JS，底层的 TLS 逻辑都是一样的）：
# 查看网站证书信息
openssl s_client -connect google.com:443 -showcerts
# 查看协商出的加密套件和会话密钥参数（需开启 SSLKEYLOGFILE）
# 环境变量：export SSLKEYLOGFILE=~/keys.log
# 然后使用 Wireshark 打开 keys.log 即可解密 HTTPS 流量查看明文
千万不要用 MD5 存密码！请使用 KDF (Key Derivation Function)。
使用 SecretKeyFactory 和 PBKDF2WithHmacSHA256。
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import java.security.SecureRandom;
import java.util.Base64;
public class PasswordHashing {
private static final int ITERATIONS = 100000;
private static final int KEY_LENGTH = 256; // bits
private static final int SALT_LENGTH = 16; // bytes
private static final String ALGO = "PBKDF2WithHmacSHA256";
public static String hashPassword(String password) throws Exception {
// 1. 生成随机盐
SecureRandom random = new SecureRandom();
byte[] salt = new byte[SALT_LENGTH];
random.nextBytes(salt);
// 2. 计算哈希
PBEKeySpec (password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
SecretKeyFactory.getInstance(ALGO);
[] hash = factory.generateSecret(spec).getEncoded();
bytesToHex(salt) + + bytesToHex(hash);
}
Exception {
String[] parts = storedHash.split();
[] salt = hexToBytes(parts[]);
[] storedHashBytes = hexToBytes(parts[]);
(inputPassword.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
SecretKeyFactory.getInstance(ALGO);
[] inputHashBytes = factory.generateSecret(spec).getEncoded();
slowEquals(storedHashBytes, inputHashBytes);
}
{
a.length ^ b.length;
( ; i < a.length && i < b.length; i++) {
diff |= a[i] ^ b[i];
}
diff == ;
}
String {
();
( b : bytes) sb.append(String.format(, b));
sb.toString();
}
[] hexToBytes(String s) {
s.length();
[] data = [len / ];
( ; i < len; i += ) {
data[i / ] = () ((Character.digit(s.charAt(i), ) << ) + Character.digit(s.charAt(i + ), ));
}
data;
}
}
使用 crypto.pbkdf2 (Async/Promise 版本)。
const crypto = require('crypto');
const ITERATIONS = 100000;
const KEY_LENGTH = 32; // 32 bytes = 256 bits
const DIGEST = 'sha256';
const SALT_LENGTH = 16;
// 使用 Promise 包装异步操作
function hashPassword(password) {
return new Promise((resolve, reject) => {
const salt = crypto.randomBytes(SALT_LENGTH);
crypto.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (err, derivedKey) => {
if (err) return reject(err);
// 存储：salt + hash (转 hex)
const stored = salt.toString('hex') + ':' + derivedKey.toString('hex');
resolve(stored);
});
});
}
function verifyPassword(storedHash, password) {
return new Promise(() => {
[saltHex, hashHex] = storedHash.();
salt = .(saltHex, );
crypto.(password, salt, , , , {
(err) (err);
derivedKeyHex = derivedKey.();
keyBuffer = .(hashHex, );
derivedBuffer = .(derivedKeyHex, );
(keyBuffer. !== derivedBuffer.) {
();
}
{
match = crypto.(keyBuffer, derivedBuffer);
(match);
} (e) {
();
}
});
});
}
( () => {
pass = ;
hash = (pass);
.(, hash);
isValid = (hash, pass);
.(, isValid);
})();
为了达到'精通'，必须了解敌人如何攻击。
| 攻击类型 | 目标算法 | 原理简述 | 防御方案 |
|---|---|---|---|
| 重放攻击 | 通信协议 | 攻击者截获有效的数据包（如转账请求），再次发送。 | 使用 Nonce (随机数) 或 Timestamp (时间戳)。GCM 模式的 Nonce 必须唯一。 |
| 中间人攻击 (MITM) | RSA/TLS | 攻击者冒充服务器，发送自己的公钥给客户端。 | 验证 数字证书链，必须由受信任的 CA 签发。 |
| 填充预言攻击 | RSA-CBC | 攻击者根据解密时的报错信息（Padding Error）逐步推断明文。 | 解密时不立即报错，使用恒定时间算法；改用 RSA-OAEP。 |
| 侧信道攻击 | 硬件/AES | 通过分析 CPU 执行时间、功耗或电磁辐射来推断密钥。 | 物理隔离；使用恒定时间实现的代码库。 |
如果你正在设计一个安全系统，请遵循以下垂直架构层级，每一层都依赖下一层的安全支撑：
应用层 Application Layer
业务逻辑
敏感数据处理
输入验证
参数清洗
接口安全 API Security
传输安全 Transport Layer
TLS 1.3 / HTTPS
存储安全 Storage Security
数据库加密 AES-256
密码存储 Argon2/PBKDF2
密钥管理 Key Management
非硬编码密钥
KMS / HSM / Vault
精通之路：理解上述每一个箭头和模块背后的数学原理与工程妥协，并有能力在性能、安全性和易用性之间找到最佳的平衡点。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online