小明给小红写情书：
原文：我喜欢你
加密：我喜欢你 → 3 6 9（每个字的拼音首字母位置）
小红收到：3 6 9
解密：3 6 9 → 我喜欢你

你的家门锁：
- 用钥匙锁门（加密）
- 用同一把钥匙开门（解密）
- 如果钥匙丢了，别人也能开门 ❌

发送方：
原文：Hello → [用密钥K加密] → 密文：X7@9#

传输：
密文：X7@9# → 网络传输 → 密文：X7@9#

接收方：
密文：X7@9# → [用同一个密钥K解密] → 原文：Hello

from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
from Crypto.Util.Padding import pad, unpad

# 1. 生成密钥（256位 = 32字节）
key = get_random_bytes(32)

# 2. 创建加密器
cipher = AES.new(key, AES.MODE_CBC)

# 3. 加密数据
plaintext = b"Hello, World!"
ciphertext = cipher.encrypt(pad(plaintext, AES.block_size))

print(f"原文: {plaintext}")
print(f"密文: {ciphertext.hex()}")

# 4. 解密数据
decipher = AES.new(key, AES.MODE_CBC, cipher.iv)
decrypted = unpad(decipher.decrypt(ciphertext), AES.block_size)

print(f"解密: {decrypted}")

邮箱系统：
- 邮箱地址（公钥）：任何人都知道，可以给你发邮件
- 邮箱密码（私钥）：只有你知道，只有你能看邮件

别人用你的邮箱地址（公钥）发邮件（加密）
只有你用密码（私钥）才能看邮件（解密）

密钥生成：
生成一对密钥 → 公钥（Public Key） + 私钥（Private Key）

加密过程：
发送方：原文 → [用接收方的公钥加密] → 密文
接收方：密文 → [用自己的私钥解密] → 原文

关键特点：
- 公钥加密的内容，只能用对应的私钥解密
- 私钥加密的内容，只能用对应的公钥解密

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

# 1. 生成密钥对
key = RSA.generate(2048)
private_key = key
public_key = key.publickey()

# 2. 加密（用公钥）
cipher = PKCS1_OAEP.new(public_key)
plaintext = b"Hello, World!"
ciphertext = cipher.encrypt(plaintext)

print(f"原文: {plaintext}")
print(f"密文: {ciphertext.hex()}")

# 3. 解密（用私钥）
decipher = PKCS1_OAEP.new(private_key)
decrypted = decipher.decrypt(ciphertext)

print(f"解密: {decrypted}")

HTTPS的加密流程：

1. 用非对称加密交换对称密钥
   客户端 → [用服务器公钥加密] → 对称密钥K → 服务器
   服务器 → [用自己私钥解密] → 得到对称密钥K

2. 用对称加密传输数据
   客户端 ←→ [用对称密钥K加密] ←→ 服务器

结果：
- 密钥分发安全（非对称加密）
- 数据传输快速（对称加密）

身份证号：
- 每个人都有唯一的身份证号
- 看到身份证号就知道是谁
- 但不能从身份证号反推出这个人的样子

哈希值：
- 每个数据都有唯一的哈希值
- 看到哈希值就知道数据是否被修改
- 但不能从哈希值反推出原始数据

输入：任意长度的数据
  ↓
哈希函数（如SHA256）
  ↓
输出：固定长度的哈希值（256位）

特点：
1. 单向性：不可逆（无法从哈希值推出原文）
2. 唯一性：不同数据的哈希值几乎不可能相同
3. 雪崩效应：数据改一个字节，哈希值完全不同

import hashlib

# 1. 计算哈希值
data = b"Hello, World!"
hash_value = hashlib.sha256(data).hexdigest()

print(f"原文: {data}")
print(f"SHA256: {hash_value}")

# 2. 验证数据完整性
data2 = b"Hello, World!"
hash_value2 = hashlib.sha256(data2).hexdigest()

if hash_value == hash_value2:
    print("✅ 数据未被修改")
else:
    print("❌ 数据已被篡改")

# 3. 雪崩效应演示
data3 = b"Hello, World?"  # 只改了一个字符
hash_value3 = hashlib.sha256(data3).hexdigest()

print(f"\n原文: {data}")
print(f"SHA256: {hash_value}")
print(f"\n改后: {data3}")
print(f"SHA256: {hash_value3}")
print("→ 完全不同！")

下载文件时：
文件 → 计算SHA256 → 对比官方提供的SHA256
  ├── 相同 → 文件完整 ✅
  └── 不同 → 文件被篡改 ❌

用户注册：
密码 → SHA256 → 存储哈希值（不存储明文密码）

用户登录：
输入密码 → SHA256 → 对比存储的哈希值

签名大文件：
文件 → SHA256 → 哈希值 → 用私钥签名
（不直接签名文件，而是签名哈希值，速度快）

手写签名：
- 你用自己的笔迹签名（私钥签名）
- 别人对比你的签名样本验证（公钥验证）
- 每个人的签名都不同，无法伪造

数字签名：
- 你用私钥对数据签名
- 别人用你的公钥验证签名
- 私钥只有你有，无法伪造

签名过程：
1. 计算数据的哈希值
   数据 → SHA256 → 哈希值

2. 用私钥加密哈希值
   哈希值 → [用私钥加密] → 签名值

3. 发送数据和签名
   数据 + 签名值 → 发送给对方

验证过程：
1. 计算收到数据的哈希值
   收到的数据 → SHA256 → 哈希值A

2. 用公钥解密签名值
   签名值 → [用公钥解密] → 哈希值B

3. 对比两个哈希值
   哈希值A == 哈希值B？
     ├── 相同 → 签名有效 ✅
     └── 不同 → 签名无效 ❌

from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256

# 1. 生成密钥对
key = RSA.generate(2048)
private_key = key
public_key = key.publickey()

# 2. 签名（用私钥）
data = b"Hello, World!"
hash_obj = SHA256.new(data)
signature = pkcs1_15.new(private_key).sign(hash_obj)

print(f"原文: {data}")
print(f"签名: {signature.hex()}")

# 3. 验证签名（用公钥）
try:
    hash_obj = SHA256.new(data)
    pkcs1_15.new(public_key).verify(hash_obj, signature)
    print("✅ 签名验证成功")
except:
    print("❌ 签名验证失败")

# 4. 篡改数据后验证
tampered_data = b"Hello, World?"
try:
    hash_obj = SHA256.new(tampered_data)
    pkcs1_15.new(public_key).verify(hash_obj, signature)
    print("✅ 签名验证成功")
except:
    print("❌ 签名验证失败（数据被篡改）")

证明：这个数据确实是我发的
原理：只有我有私钥，只有我能生成这个签名

证明：数据没有被篡改
原理：数据改一个字节，签名验证就会失败

证明：你不能否认是你发的
原理：私钥只有你有，签名就是证据

场景：小明给小红发送加密消息

步骤1：小明用小红的公钥加密消息
消息 → [用小红的公钥加密] → 密文
（非对称加密，保证只有小红能看）

步骤2：小明用自己的私钥签名
消息 → SHA256 → 哈希值 → [用小明的私钥签名] → 签名
（数字签名，证明是小明发的）

步骤3：小明发送密文和签名
密文 + 签名 → 发送给小红

步骤4：小红验证签名
签名 → [用小明的公钥验证] → 验证通过 ✅
（确认是小明发的，数据未被篡改）

步骤5：小红解密消息
密文 → [用小红的私钥解密] → 消息
（只有小红能解密）

┌─────────────────────────────────────┐
│           加密通信体系               │
├─────────────────────────────────────┤
│                                     │
│  对称加密（AES）                     │
│    └── 用途：加密大量数据            │
│                                     │
│  非对称加密（RSA）                   │
│    ├── 用途1：交换对称密钥           │
│    └── 用途2：数字签名               │
│                                     │
│  哈希函数（SHA256）                  │
│    ├── 用途1：数据完整性校验         │
│    ├── 用途2：密码存储               │
│    └── 用途3：数字签名（签名哈希值） │
│                                     │
│  数字签名                            │
│    └── 组合：哈希函数 + 非对称加密   │
│                                     │
└─────────────────────────────────────┘

1. 浏览器 → 服务器：你好，我要访问你
2. 服务器 → 浏览器：这是我的证书（包含公钥）
3. 浏览器验证证书（数字签名）
4. 浏览器生成对称密钥K
5. 浏览器 → 服务器：[用服务器公钥加密]对称密钥K
6. 服务器解密得到对称密钥K
7. 双方用对称密钥K加密通信

使用的技术：
- 非对称加密（RSA）：交换对称密钥
- 对称加密（AES）：加密数据传输
- 哈希函数（SHA256）：验证数据完整性
- 数字签名：验证服务器身份

1. 官网提供：软件 + SHA256哈希值
2. 用户下载软件
3. 用户计算下载文件的SHA256
4. 对比官网提供的SHA256
   ├── 相同 → 文件完整，未被篡改 ✅
   └── 不同 → 文件被篡改，不要安装 ❌

使用的技术：
- 哈希函数（SHA256）：验证文件完整性

1. 交易数据 → SHA256 → 哈希值
2. 用私钥签名哈希值 → 签名
3. 广播：交易数据 + 签名
4. 其他节点用公钥验证签名
5. 验证通过 → 交易有效

使用的技术：
- 哈希函数（SHA256）：计算区块哈希
- 数字签名（ECDSA）：证明交易真实性

对称加密一把钥匙快，
非对称加密两把钥匙安全。
哈希函数算指纹，
数字签名证身份。