加密与编码算法详解：Java 与 JavaScript 实现

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);
    }
}

JavaScript (Node.js)

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
    const iv = buffer.subarray(0, IV_LENGTH);
    const authTag = buffer.subarray(IV_LENGTH, IV_LENGTH + 16); // GCM Tag 默认 16 bytes
    const ciphertext = buffer.subarray(IV_LENGTH + 16);
    // 3. 创建解密器并设置 AuthTag (验证数据完整性的关键)
    const decipher = crypto.createDecipheriv(ALGO_NAME, key, iv);
    decipher.setAuthTag(authTag);
    // 4. 解密
    let decrypted = decipher.update(ciphertext);
    decrypted = Buffer.concat([decrypted, decipher.final()]);
    return decrypted.toString('utf8');
}

// 使用示例
const key = crypto.randomBytes(KEY_LENGTH); // 生成随机密钥
const msg = "Top Secret Message";
const encrypted = encrypt(msg, key);
console.log("Encrypted:", encrypted);
const decrypted = decrypt(encrypted, key);
console.log("Decrypted:", decrypted);

3. 非对称加密：RSA 的数理逻辑

RSA 的安全性依赖于大整数分解难题。

3.1 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)

3.2 填充的重要性：OAEP

直接用 RSA 加密数据（教科书式 RSA）是极其危险的。必须使用填充。OAEP (Optimal Asymmetric Encryption Padding) 是目前的标准。

为何需要 OAEP？ 没有填充的 RSA 是确定性的（相同的明文永远得到相同的密文），且容易满足特定数学结构导致被破解。OAEP 引入了随机性，使加密变成概率性的。

3.3 实战：RSA-OAEP 加密与解密

注意：RSA 速度慢，通常只用来加密对称密钥，不直接加密大文件。

Java (JDK 11+)

使用 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("Decrypted: " + new String(decryptedBytes));
    }
}

JavaScript (Node.js)

使用 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());

4. 数字签名：身份验证

数字签名是'私钥加密哈希'的现代严谨说法（实际操作略有不同，常用 PSS 填充）。

4.1 签名生成与验证流程

下图展示了发送方如何使用私钥签名，接收方如何使用公钥验证身份和完整性：

发送方：
1. 准备数据
2. 计算原始消息的哈希值 Hash_A
3. 使用私钥加密 Hash_A 生成签名 Signature
4. 发送 [原始消息] + [数字签名]

接收方：
1. 计算收到消息的哈希值 Hash_B
2. 使用公钥解密签名 得到 Hash_A
3. 验证 Hash_A == Hash_B
   ✅ 验证通过 (数据完整且来源真实)
   ❌ 验证失败 (数据已篡改或来源伪造)

4.2 实战：RSASSA-PSS 签名

Java 11+ 和 Node.js 均原生支持 PSS 填充，这是比 PKCS#1 v1.5 更安全的签名方案。

Java (JDK 11+)

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, 32, 1));
        verifier.initVerify(keyPair.getPublic());
        verifier.update(message.getBytes());
        boolean isValid = verifier.verify(signatureBytes);
        System.out.println("Signature valid? " + isValid);
    }
}

JavaScript (Node.js)

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.RSA_PKCS1_PSS_PADDING,
    saltLength: crypto.constants.RSA_PSS_SALTLEN_DIGEST
}, signature);
console.log("Signature valid?", isValid);

5. 混合加密实战：HTTPS (TLS 1.2) 握手全流程

这是现代互联网安全的基础，结合了非对称加密（交换密钥）和对称加密（传输数据）。

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（往返延迟）。

5.1 实战：使用 OpenSSL 分析 HTTPS 握手

作为开发者，你可以使用命令行工具验证上述流程（无论你用 Java 还是 JS，底层的 TLS 逻辑都是一样的）：

# 查看网站证书信息
openssl s_client -connect google.com:443 -showcerts

# 查看协商出的加密套件和会话密钥参数（需开启 SSLKEYLOGFILE）
# 环境变量：export SSLKEYLOGFILE=~/keys.log
# 然后使用 Wireshark 打开 keys.log 即可解密 HTTPS 流量查看明文

6. 密码存储与哈希：PBKDF2 实战

千万不要用 MD5 存密码！请使用 KDF (Key Derivation Function)。

Java (JDK 8+)

使用 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 spec = new PBEKeySpec(password.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGO);
        byte[] hash = factory.generateSecret(spec).getEncoded();
        // 3. 存储：salt + hash (转 Hex)
        return bytesToHex(salt) + ":" + bytesToHex(hash);
    }

    public static boolean verifyPassword(String storedHash, String inputPassword) throws Exception {
        String[] parts = storedHash.split(":");
        byte[] salt = hexToBytes(parts[0]);
        byte[] storedHashBytes = hexToBytes(parts[1]);
        // 4. 使用同样的盐计算输入密码的哈希
        PBEKeySpec spec = new PBEKeySpec(inputPassword.toCharArray(), salt, ITERATIONS, KEY_LENGTH);
        SecretKeyFactory factory = SecretKeyFactory.getInstance(ALGO);
        byte[] inputHashBytes = factory.generateSecret(spec).getEncoded();
        // 5. 对比
        return slowEquals(storedHashBytes, inputHashBytes);
    }

    // 辅助：防时序攻击比较
    private static boolean slowEquals(byte[] a, byte[] b) {
        int diff = a.length ^ b.length;
        for (int i = 0; i < a.length && i < b.length; i++) {
            diff |= a[i] ^ b[i];
        }
        return diff == 0;
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) sb.append(String.format("%02x", b));
        return sb.toString();
    }

    private static byte[] hexToBytes(String s) {
        int len = s.length();
        byte[] data = new byte[len / 2];
        for (int i = 0; i < len; i += 2) {
            data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i + 1), 16));
        }
        return data;
    }
}

JavaScript (Node.js)

使用 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((resolve, reject) => {
        const [saltHex, hashHex] = storedHash.split(':');
        const salt = Buffer.from(saltHex, 'hex');
        crypto.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (err, derivedKey) => {
            if (err) return reject(err);
            const derivedKeyHex = derivedKey.toString('hex');
            // 使用 crypto.timingSafeEqual 防止时序攻击
            const keyBuffer = Buffer.from(hashHex, 'hex');
            const derivedBuffer = Buffer.from(derivedKeyHex, 'hex');
            if (keyBuffer.length !== derivedBuffer.length) {
                return resolve(false);
            }
            try {
                const match = crypto.timingSafeEqual(keyBuffer, derivedBuffer);
                resolve(match);
            } catch (e) {
                resolve(false);
            }
        });
    });
}

// 使用示例
(async () => {
    const pass = "my_secure_pass";
    const hash = await hashPassword(pass);
    console.log("Stored in DB:", hash);
    const isValid = await verifyPassword(hash, pass);
    console.log("Check result:", isValid);
})();

7. 技术深度补充：常见攻击与防御

为了达到'精通'，必须了解敌人如何攻击。

8. 总结：现代安全架构设计图

如果你正在设计一个安全系统，请遵循以下垂直架构层级，每一层都依赖下一层的安全支撑：

应用层 Application Layer
业务逻辑
敏感数据处理
输入验证
参数清洗

接口安全 API Security

传输安全 Transport Layer
TLS 1.3 / HTTPS

存储安全 Storage Security
数据库加密 AES-256
密码存储 Argon2/PBKDF2

密钥管理 Key Management
非硬编码密钥
KMS / HSM / Vault

精通之路：理解上述每一个箭头和模块背后的数学原理与工程妥协，并有能力在性能、安全性和易用性之间找到最佳的平衡点。