1
# Python 密码学示例（使用 cryptography 库）
2
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
3
from cryptography.hazmat.primitives import hashes, serialization
4
from cryptography.hazmat.primitives.asymmetric import rsa, padding
5
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
6
import os
7

8
# === 对称加密：AES-GCM（机密性 + 完整性） ===
9
key = os.urandom(32)  # 256-bit key
10
nonce = os.urandom(12)  # 96-bit nonce（GCM 推荐 96 位）
11
cipher = Cipher(algorithms.AES(key), modes.GCM(nonce))
12
encryptor = cipher.encryptor()
13
ciphertext = encryptor.update(b"敏感数据：余额 1000000 元") + encryptor.finalize()
14
tag = encryptor.tag  # 认证标签，用于验证完整性
15

16
# 解密时验证 tag
17
decryptor = Cipher(algorithms.AES(key), modes.GCM(nonce, tag)).decryptor()
18
plaintext = decryptor.update(ciphertext) + decryptor.finalize()
19

20
# === 非对称加密：RSA-OAEP（密钥交换） ===
21
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
22
public_key = private_key.public_key()
23
ciphertext = public_key.encrypt(
24
    b"对称密钥材料",
25
    padding.OAEP(
26
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
27
        algorithm=hashes.SHA256(),
28
        label=None
29
    )
30
)
31

32
# === 哈希：SHA-256（完整性） ===
33
digest = hashes.Hash(hashes.SHA256())
34
digest.update(b"需要验证完整性的数据")
35
hash_value = digest.finalize()  # 32 字节的摘要
36

37
# === 密码存储：PBKDF2（慢哈希，抗暴力破解） ===
38
salt = os.urandom(16)
39
kdf = PBKDF2HMAC(
40
    algorithm=hashes.SHA256(),
41
    length=32,
42
    salt=salt,
43
    iterations=600000,  # 迭代次数越高，暴力破解越慢
44
)
45
password_hash = kdf.derive(b"用户密码")  # 存储 salt + password_hash

1
// Go 密码学示例（使用 crypto 标准库）
2
package main
3

4
import (
5
    "crypto/aes"
6
    "crypto/cipher"
7
    "crypto/rand"
8
    "crypto/sha256"
9
    "fmt"
10
    "io"
11
)
12

13
func main() {
14
    // === 对称加密：AES-GCM ===
15
    key := make([]byte, 32) // 256-bit key
16
    rand.Read(key)
17

18
    block, _ := aes.NewCipher(key)
19
    gcm, _ := cipher.NewGCM(block)
20

21
    nonce := make([]byte, gcm.NonceSize())
22
    io.ReadFull(rand.Reader, nonce)
23

24
    plaintext := []byte("敏感数据：余额 1000000 元")
25
    ciphertext := gcm.Seal(nil, nonce, plaintext, nil)
26
    // ciphertext 包含加密数据 + 认证标签
27

28
    // 解密并验证
29
    decrypted, err := gcm.Open(nil, nonce, ciphertext, nil)
30
    if err != nil {
31
        fmt.Println("完整性验证失败！数据可能被篡改")
32
        return
33
    }
34
    fmt.Printf("解密成功: %s\n", decrypted)
35

36
    // === 哈希：SHA-256 ===
37
    hash := sha256.Sum256([]byte("需要验证完整性的数据"))
38
    fmt.Printf("SHA-256: %x\n", hash)
39
}

1
# Python 密码学示例
2
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
3
from cryptography.hazmat.primitives import hashes, serialization
4
from cryptography.hazmat.primitives.asymmetric import rsa, padding
5
import os
6

7
# 对称加密：AES-GCM
8
key = os.urandom(32)  # 256-bit key
9
nonce = os.urandom(12)  # 96-bit nonce
10
cipher = Cipher(algorithms.AES(key), modes.GCM(nonce))
11
encryptor = cipher.encryptor()
12
ciphertext = encryptor.update(b"Hello, World!") + encryptor.finalize()
13
tag = encryptor.tag
14

15
# 非对称加密：RSA
16
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
17
public_key = private_key.public_key()
18
ciphertext = public_key.encrypt(
19
    b"Secret message",
20
    padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None)
21
)
22

23
# 哈希：SHA-256
24
digest = hashes.Hash(hashes.SHA256())
25
digest.update(b"Hello, World!")
26
hash_value = digest.finalize()

1
# OpenSSL 常用操作速查
2
# 生成 RSA-2048 密钥对
3
openssl genrsa -out private.pem 2048
4
openssl rsa -in private.pem -pubout -out public.pem
5

6
# SHA-256 哈希校验
7
openssl dgst -sha256 -hex message.txt
8

9
# AES-256-GCM 加密
10
openssl enc -aes-256-gcm -salt -in plaintext.txt -out ciphertext.bin -pass pass:your-key

1
# Python cryptography 库快速上手
2
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
3
from cryptography.hazmat.primitives import hashes
4
import os
5

6
# AES-GCM 加密（推荐模式）
7
key = os.urandom(32)      # 256-bit 密钥
8
nonce = os.urandom(12)    # 96-bit nonce
9
cipher = Cipher(algorithms.AES(key), modes.GCM(nonce))
10
enc = cipher.encryptor()
11
ct = enc.update(b"敏感数据") + enc.finalize()
12
tag = enc.tag  # 认证标签，解密时必须验证
13

14
# SHA-256 哈希
15
digest = hashes.Hash(hashes.SHA256())
16
digest.update(b"待校验数据")
17
hash_value = digest.finalize()  # 32 字节摘要

1
// Go: 模拟 TLS 配置的最佳实践
2
package main
3

4
import (
5
    "crypto/tls"
6
    "crypto/x509"
7
    "io"
8
    "net/http"
9
    "os"
10
)
11

12
func main() {
13
    // 创建安全的 TLS 配置
14
    tlsConfig := &tls.Config{
15
        MinVersion: tls.VersionTLS13, // 强制 TLS 1.3
16
        CipherSuites: []uint16{
17
            tls.TLS_AES_256_GCM_SHA384,
18
            tls.TLS_CHACHA20_POLY1305_SHA256,
19
            tls.TLS_AES_128_GCM_SHA256,
20
        },
21
    }
22

23
    // 加载 CA 证书（证书验证）
24
    caCert, _ := io.ReadAll(os.Stdin) // 实际中从文件读取
25
    caCertPool := x509.NewCertPool()
26
    caCertPool.AppendCertsFromPEM(caCert)
27
    tlsConfig.RootCAs = caCertPool
28

29
    // 创建 HTTP 客户端
30
    client := &http.Client{
31
        Transport: &http.Transport{
32
            TLSClientConfig: tlsConfig,
33
        },
34
    }
35
    _ = client // 使用 client.Get("https://example.com")
36
}

1
# Python: 字段级加密示例（信封加密模式）
2
from cryptography.fernet import Fernet
3
import json
4

5
# 模拟 KMS 提供的数据加密密钥（DEK）
6
dek = Fernet.generate_key()  # 实际中由 KMS 生成并管理
7
fernet = Fernet(dek)
8

9
# 加密敏感字段
10
user_record = {
11
    "id": 1001,
12
    "name": "张三",
13
    "id_number": fernet.encrypt("110101199001011234".encode()).decode(),  # 加密
14
    "phone": fernet.encrypt("13800138000".encode()).decode(),  # 加密
15
    "status": "active",  # 非敏感字段不加密
16
}
17

18
# 存入数据库
19
print(json.dumps(user_record, ensure_ascii=False, indent=2))
20
# {"id": 1001, "name": "张三", "id_number": "gAAAAA...", "phone": "gAAAAA...", "status": "active"}
21

22
# 查询时解密
23
id_number = fernet.decrypt(user_record["id_number"].encode()).decode()
24
phone = fernet.decrypt(user_record["phone"].encode()).decode()

1
# Python: HMAC 签名验证 API 请求
2
import hmac
3
import hashlib
4
import time
5

6
def sign_api_request(api_key: str, api_secret: str, method: str, path: str, body: str) -> dict:
7
    """生成带 HMAC 签名的 API 请求头"""
8
    timestamp = str(int(time.time()))
9
    message = f"{method}\n{path}\n{timestamp}\n{body}"
10

11
    # HMAC-SHA256 签名
12
    signature = hmac.new(
13
        api_secret.encode(),
14
        message.encode(),
15
        hashlib.sha256
16
    ).hexdigest()
17

18
    return {
19
        "X-API-Key": api_key,
20
        "X-Timestamp": timestamp,
21
        "X-Signature": signature,
22
    }
23

24
# 服务端验证签名
25
def verify_signature(api_secret: str, method: str, path: str,
26
                     timestamp: str, body: str, received_sig: str) -> bool:
27
    """验证 API 请求签名"""
28
    # 防重放攻击：检查时间戳（5 分钟有效期）
29
    if abs(time.time() - int(timestamp)) > 300:
30
        return False
31

32
    message = f"{method}\n{path}\n{timestamp}\n{body}"
33
    expected_sig = hmac.new(
34
        api_secret.encode(),
35
        message.encode(),
36
        hashlib.sha256
37
    ).hexdigest()
38

39
    # 使用 hmac.compare_digest 防止时序攻击
40
    return hmac.compare_digest(expected_sig, received_sig)