一，哈希函数（Hash function）
*（1）、哈希函数可以把整个文件压缩成很短的东西，一个文件榨出来的哈希长度永远一样，这是哈希的特性
哈希 = 榨指纹
1，指纹有着不可逆性（你没法从一个人的指纹上反推这个人多高、多重、长什么样）
2，指纹有着稳定性（同一个人按两次手印，指纹是一样的）
3，指纹有着压缩性（就好似把你一整个人压缩成一个手印）
就像SHA-256能把任意长度的东西压缩成固定64字符的“指纹”，特性：哪怕指纹错一个字母，64位数的整体也会变得面目全非

import hashlib
text = "cat"
result = hashlib.sha256(text.encode()).hexdigest()
print(result)

这是一串可以模拟哈希的python代码，可以把任意文本压缩成指纹
*（2）、哈希函数在网络安全里一般用来干什么
用途一：存密码，不存明文一个网站的数据库如果直接存你账号的密码，数据库一泄露，你的密码就裸奔了
正确的做法是存哈希，注册时你输密码（例如123456）网站就会榨出其指纹存放、当你登录时，网站就会把你输入的密码再次压榨成哈希值与已存放的哈希值密码进行对比，一样就=ture通过
当数据库泄露，攻击者拿到的是一串指纹，推不出你的密码（就算拿着哈希值在登录页输入也会把哈希再次炸成指纹：密码不相似无法登录你的账号）

二、对称函数（AES）
哈希好是好但是有一个“缺点”：不可逆，这本来是件好事，但是现实里有件事，很多时候它必须能还原
比如说你跟你朋友传一句悄悄话，但是你不想被半路的人听到，于是你把话打乱，你朋友收到之后得还能还原成原话
这种需要能还原的变换就叫加密（所以哈希 = 只进不出，不可逆  加密 = 可进可出，可还原）
（1）、凯撒密码：字母往后移一位
最简单的加密，两千年前罗马的凯撒就用过，规则只有一条：把每个字母，往字母表后面移 1 位（z 后面绕回 a）。
拿 cat 手算一下：c → 后面一位是 da → 后面一位是 bt → 后面一位是 u
所以 cat 加密后变成 dbu。朋友拿到 dbu，怎么还原？每个字母往前移 1 位，dbu → cat。
这个"移 1 位"，就是钥匙。锁上（加密）：字母往后移 1 位，打开（解密）：字母往前移 1 位
锁和开用的是同一把钥匙（同一个"移 1 位"的规则）所以这种加密叫 对称加密
但是凯撒加密并不安全，一种加密安不安全，不看它规则多聪明，就看钥匙有多少种可能，密钥空间有多大。攻击者拿到凯撒密文很容易推算出明文
（2）、AES加密
凯撒的病根：钥匙种类太少，AES治好了这个病，“把钥匙的可能数量做大，做到物理上试不完”
AES 的钥匙是 128 位，也就是 128 个格子，吗？不，每格0或1（bit），这么多格子一共能排出 2 的 128 次方种组合，这个数大到什么程度：全世界所有电脑一起算，算到宇宙毁灭也试不完一个零头。所以想暴力破解AES物理上不可能。
AES	先把数据切成一块一块（每块 16 字节），然后对整块一起搅拌，块里的字节你中有我、我中有你地搅成一团，它安全不是因为规则聪明，而是因为"钥匙有 2¹²⁸ 种，试不完
（3）、AES模式
那么这里就冒出了一个新问题：每一块具体怎么加密？ 是每块独立各搅各的，还是块和块之间互相影响？这个怎么加密每一块的规则，就叫 模式（mode），模式选得不对，AES 再强也会出毛病
    最简单的模式 ECB
规则就一句：
每一块，用同一把钥匙、同样的方式，各自独立加密。块和块之间互不搭理。
但它漏了一个致命的东西—重复。如果原文里有两块内容一摸一样，ECB就会把这两块加密成一摸一样的密文，原文里哪里重复，密文里哪里就重复。 攻击者根本不用破解钥匙，光看密文里"哪些块长得一样"，就能猜出原文的结构
一个新概念：填充（padding）
AES只吃整块，每一块必须刚好 16 字节。那问题来了：我想加密 hello，它只有 5 字节，凑不满 16 字节，怎么办？解法叫填充（padding）：在末尾补一些东西，把 5 字节硬凑到 16 字节。加密前先填充，解密后再把补的东西去掉
示例代码：

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

key = "1234567890abcdef".encode()
data = "hello".encode()

cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(pad(data, 16))
print("密文：", ciphertext)
plain = unpad(cipher.decrypt(ciphertext), 16)
print("解密回来：", plain)

CBC/CTR/GCM就不深入探索了

三、非对称加密（RSA）
非对称加密相当于拥有两把钥匙，加密与解密用的是非相同密钥
还是跟上次一样，想象你跟你朋友传递悄悄话，你生成一把AES钥匙用它加密消息发送给朋友，但是你朋友没有钥匙，你得把钥匙发给他，但是怎么发，用消息发和打电话都可能被监听
把钥匙安全送到对方手里"这件事，本身又需要一条安全通道，钥匙配送难题（key distribution problem）就此诞生，对称加密一百多年都解不掉的死结，对称加密里，"能锁"和"能开"是同一把钥匙。
那能不能把"锁"和"开"拆成两把不同的钥匙? 这就是 RSA 的全部想法，公钥（public key）是公开的用于加密的钥匙，不能解密。私钥（private key）是私人用于解密的钥匙
于是你跟你朋友发消息的流程就变成了：
1、你生成一对钥匙：公钥 + 私钥。
2、你把公钥公开（发邮件、贴门口都行），私钥锁进自己抽屉。
3、朋友用你的公钥把消息锁上，发给你。
4、半路小偷看到了密文，他也有你的公钥（因为是公开的），但公钥只能锁、不能开，所以他打不开。
5、只有你，用抽屉里的私钥，才打得开。

取余：
取余，就是除法里的余数。就跟小学数学一样，17 ÷ 5 = 3 余 2，数学上写成 17 mod 5 = 2
RSA 的魔法锁：一个正着容易，反着难的单向门素数（也叫质数）= 只能被 1 和自己整除的数，所以公钥等于n = q × p 私钥等于q × p = n，看着没有很难，但数字变大，难度就会变得极大甚至不可能算完
下面是一段python示例代码（小素数RSA）：# ---- 第一步：造钥匙 ----p, q = 3, 11
n = p * q                # 33（公开）
phi = (p - 1) * (q - 1)  # 20（保密）
e = 3                    # 公钥的 e
d = 7                    # 私钥的 d# ---- 第二步：朋友用公钥 (e, n) 锁上 ----m = 4
c = pow(m, e, n)         # 4 的 3 次方，再 mod 33
print("密文：", c)# ---- 第三步：你用私钥 (d, n) 打开 ----m2 = pow(c, d, n)        # 密文 31 的 7 次方，再 mod 33
print("解密回来：", m2)

四、DH密钥交换
一个新问题：两个人怎么偷偷约定一把钥匙，两个人从没见过面、没提前商量，只能在一个被偷听的公开频道上说话。他们怎么偷偷约定一把钥匙（好拿去做 AES）？
DH = 咱俩共同凑出一把钥匙，谁也没"发"钥匙。
你和朋友公开约定一个"底色"：黄色（全世界知道，没关系）。
你偷偷选自己的秘密色 红色，把黄+红调成橙色，公开发出去。
朋友偷偷选他的秘密色 蓝色，把黄+蓝调成绿色，公开发出去。
你拿到朋友的绿色，掺进你的秘密红色 → 得到一种"共同的混合色"。
朋友拿到你的橙色，掺进他的秘密蓝色 → 得到同一种"共同的混合色"

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。