📖 前言：我们在登录QQ有时会遇到密码忘记的问题，那么思考一下，为什么腾讯公司不直接把密码发还给用户而是要求设置新密码呢。其实，不保存密码，是为了更好地对密码保密，换言之，腾讯的数据库根本没有存储你的密码。那腾讯又是怎么判断你的登录安全性呢，接下来的哈希函数就是其原理所在。
目录
🕒 0. 思维导图🕒 1. Hash函数🕒 2. Hash函数的应用🕘 2.1 消息认证🕤 2.1.1 使用哈希函数检查数据完整性🕤 2.1.2 中间人攻击🕤 2.1.3 解决攻击的方案
🕘 2.2 数字签名🕘 2.3 其他应用🕤 2.3.1 存储口令🕤 2.3.1 安全检测
🕘 2.4 实际应用（了解）
🕒 3. 两个简单的Hash函数🕘 3.1 XOR🕘 3.2 移位XOR
🕒 4. 密码学Hash函数的安全需求🕒 5. 攻击🕘 5.1 穷举攻击🕘 5.2 密码分析
🕒 6. 安全Hash算法🕒 7. SHA-512🕘 7.1 附加填充位（步骤1）🕘 7.2 附加长度位（步骤2）🕘 7.3 缓冲区初始化（步骤3）🕘 7.4 分组处理（步骤4）🕘 7.5 迭代函数F🕤 7.5.1 F中的轮函数R
🕒 8. SHA-512计算示例
🕒 0. 思维导图
🕒 1. Hash函数
Hash 函数，也称散列函数可以将可变长度的数据块M 作为输入，产生一个固定长度的Hash值
𝒉
=
𝑯
(
𝑴
)
𝒉=𝑯(𝑴)
h=H(M)
“好”的Hash
对于较大的输入集合
𝑴
𝟏
,
𝑴
𝟐
,
.
.
𝑴
𝒏
{𝑴_𝟏, 𝑴_𝟐,.. 𝑴_𝒏}
M1,M2,..Mn,分别使用Hash函数进行处理，产生的输出结果
𝒉
𝟏
,
𝒉
𝟐
,
.
.
𝒉
𝒏
{𝒉_𝟏, 𝒉_𝟐,.. 𝒉_𝒏}
h1,h2,..hn各元素的值是均匀分布、看起来随机的换句话说，若数据块𝑴 任何一位或几位改变了，都将产生不同的Hash值，保证了数据完整性
密码学哈希函数
𝒉
=
𝑯
(
𝑴
)
，
𝑴
≠
𝑯
−
(
𝒉
)
𝒉=𝑯(𝑴)，𝑴 {\color{red}≠} 𝑯^− (𝒉)
h=H(M)，M=H−(h)
𝒉
𝟏
=
𝑯
(
𝑴
𝟏
)
，
𝒉
𝟐
=
𝑯
(
𝑴
𝟐
)
𝒉_𝟏=𝑯(𝑴_𝟏 )，𝒉_𝟐=𝑯(𝑴_𝟐 )
h1=H(M1)，h2=H(M2)
𝒉
𝟏
≠
𝒉
𝟐
𝒉_𝟏 {\color{red}≠} 𝒉_𝟐
h1=h2
应用在网络安全中的Hash函数称为密码学Hash
已知Hash值，无法计算出对应的数据块——单向
数据块不同，生成的Hash值不同——抗碰撞
数据块M的长度为L位，在数据块M的后方增加填充内容P以及长度信息L填充后的信息变为某固定长度的整数倍，便于Hash函数处理Hash函数读取填充后的信息，生成固定长度的Hash值
例子：
将Hash值 与消息M一起发送攻击者将其截获，但不知道消息长度L，无法确认哪里是消息与填充内容的边界，提高了攻击者篡改消息的难度。
🕒 2. Hash函数的应用
🕘 2.1 消息认证
消息认证 是用来验证消息完整性的一种机制；确保接收方Alice收到的数据确实和发送方Bob发出的数据一样，没有非授权的修改、插入、删除和重放；消息认证 还要对发送方声称的身份进行认证；当Hash 用于消息认证时，Hash值也称为消息摘要
🕤 2.1.1 使用哈希函数检查数据完整性
Alice 要发送的消息为data，使用Hash函数计算出消息的Hash值
H
H
H将
H
H
H拼接到data的后面，一起发送给BobBob 接收后，从数据中将
n
n
n位Hash值
H
H
H提取出来将剩余数据data’再次使用Hash函数进行计算将得到的Hash值
H
1
H1
H1与接收到的
H
H
H进行比较二者不同，说明消息data或者传递的Hash值遭受了篡改
🕤 2.1.2 中间人攻击
Alice 给 Bob 发送消息data，计算出Hash值为
H
H
H，将
H
H
H拼接在data后面，一起发送给BobDarth 截获了该数据，并且他已知数据的最后
n
n
n位为Hash值，因此截取出了原始明文消息dataDarth 把原始消息篡改为data’，重新计算其Hash值，并附在data’后面一起转发给BobBob 收到篡改后的数据以及更新的Hash值，即使对消息data’进行Hash计算，也无法发现异常为防止中间人攻击，Alice 对消息data 计算生成的Hash值必须得到保护
🕤 2.1.3 解决攻击的方案
方法一：消息
M
M
M与哈希值
H
(
M
)
H(M)
H(M)均对称加密并传输
A给B发送消息𝑴 ， 𝑴的Hash值为𝑯(𝑴)，拼接得
𝑴
∥
𝑯
(
𝑴
)
𝑴∥𝑯(𝑴)
M∥H(M)使用密钥𝑲 与 对称加密算法𝑬 为数据加密，生成
𝑬
(
𝑲
,
𝑴
∥
𝑯
)
𝑬( 𝑲,𝑴∥𝑯 )
E(K,M∥H)B 收到密文后，使用只有双方共享的密钥𝑲 解密，确认了消息一定来源于 A解密得到
𝑴
∥
𝑯
(
𝑴
)
𝑴∥𝑯(𝑴)
M∥H(M)，再次使用Hash 对𝑴 进行计算，得到的值必然是𝑯(𝑴)，确认了消息未被更改
Q：现在密钥K是绝对保密的，若攻击者截获了传输的数据，他能看到消息M 是什么吗？ A：不能
❗ 转载请注明出处 作者：HinsCoder 博客链接：🔎 作者博客主页
方法二：只对称加密哈希值并传输
A给B发送消息𝑴 ， 𝑴的Hash值为𝑯(𝑴)，加密得
𝑬
(
𝑲
,
𝑯
(
𝑴
)
)
𝑬( 𝑲, 𝑯(𝑴) )
E(K,H(M))将加密后的Hash值 拼接在消息𝑴 后，一起发出
𝑴
∥
𝑬
(
𝑲
,
𝑯
(
𝑴
)
)
𝑴∥𝑬( 𝑲, 𝑯(𝑴) )
M∥E(K,H(M))B 收到后，对后n位数据使用只有双方共享的密钥𝑲 解密，得到了Hash值，并且只有B 才能看到 Hash值若对消息𝑴 进行计算得到的值与该Hash值相同，确认了消息未发生篡改
Q：现在密钥K是绝对保密的，若攻击者截获了传输的数据，并已知Hash值长度，那么他能看到消息M 是什么吗？ A：可以 Q：若攻击者截获了传输的数据并修改了M，他能否也篡改数据中的Hash值，使得接收方无法察觉？ A：不能
方法三：双方共享校验值
通信双方共享一个秘密值SA 将消息M 和秘密值S 串联后，计算其Hash值，并将得到的Hash值 附在消息M 后发送给BB 收到后，将双方预先知道的秘密值S 拼在M后，计算出Hash值，若与接收到的Hash值相同，说明消息未篡改秘密值S 本身没有在信道中传送
Q：若攻击者截获了传输的数据，并已知Hash值的长度，他能否获取到消息M？ A：能 Q：若攻击者截获了传输的数据并修改了M，他能否也篡改数据中的Hash值，使得接收方无法察觉？ A：不能
方法四：消息
M
M
M与哈希值
H
(
M
)
H(M)
H(M)均对称加密并加入校验值
在方案三的基础上，使用双方共享的密钥K与对称加密算法E 来为消息M 与Hash值H 一起加密即保证了消息的保密性，也保证了完整性
🕘 2.2 数字签名
方法一：非对称加密哈希值并传输
A给B发送消息𝑴 ， 𝑴的Hash值为𝑯(𝑴)，加密得
𝑬
(
𝑷
𝑹
𝑨
，
𝑯
(
𝑴
)
)
𝑬( 𝑷𝑹_𝑨，𝑯(𝑴) )
E(PRA，H(M))，注意是发送方的私钥将加密后的Hash值 拼接在消息𝑴 后，一起发出B 收到后，对消息𝑴 计算其Hash值使用发送方A的公钥
𝑷
𝑼
𝑨
𝑷𝑼_𝑨
PUA 来解密后半部分，得到了原始Hash值，若二者相同说明消息未被篡改
Q：若攻击者截获了传输的数据，并已知Hash值长度，他能否获取到消息M？ A：能 Q：若攻击者截获了传输的数据并修改了M，他能否也篡改数据中的Hash值，使得接收方无法察觉？ A：不能
方法二：
若既要保证消息的完整性，又要保证消息的保密性，可以在数字签名的基础上为 消息M 和 加密Hash值 一起使用密钥K 进行对称加密
Q：现在密钥K是绝对保密的，若攻击者截获了传输的数据，他能否获取到消息M？ A：不能
🕘 2.3 其他应用
🕤 2.3.1 存储口令
Hash函数常被用于产生单向口令文件即使黑客能够访问用户口令文件，看到的也只是口令的Hash值，无法得到真正的口令
🕤 2.3.1 安全检测
Hash函数也可用于入侵检测或病毒检测将每个文件的Hash值 H(F) 存储在安全系统中，通过定期重新计算H(F)，来判断文件是否被修改过
🕘 2.4 实际应用（了解）
比特币是于2008年发明的一种加密货币，并于2009年以其开源软件的形式发布。它是一种分散（去中心化）的数字货币，无需中央银行或单一管理员。 可以在对等比特币网络上从一个用户发送到另一个用户，而无需中介。每个参与交易的人都拥有“账本” 。在某个用户更新账本数据的时候，就要通知其他用户一起修改账本记录。保密性：进行交易时使用收款人的公钥进行加密认证性：进行交易时使用发款人的私钥进行身份认证完整性：每个用户拥有的“账本”是交易记录，交易记录分成各个区块，每个区块用HASH函数进行HASH码的生成，并与其他区块链接到一起
🕒 3. 两个简单的Hash函数
🕘 3.1 XOR
若分组第一位始终为0，那么Hash的第一位也始终为0Hash 与明文统计规律相关，不安全
🕘 3.2 移位XOR
对当前Hash进行循环左移，消除同一经度的统计规律使得 Hash值 更随机、更安全
思考：上面两个函数是真正的哈希函数吗？ 答：哈希函数的一大特征：单向性，而异或是有办法逆向的
🕒 4. 密码学Hash函数的安全需求
可变输入 Hash函数 可应用于任意大小的数据块
固定长度 Hash函数 产生的是固定长度的输出
计算效率 对任意消息x，计算H(x)容易，硬件软件均可实现
抗原像攻击 对于Hash值 𝒉=𝑯(𝒙) ，称𝒙是𝒉的原像 给定𝒉，找到满足𝒉=𝑯(𝒙) 的 𝒙 在计算上不可行，即不能通过哈希值反推出明文
抗弱碰撞 对任意给定的𝒙，找到满足𝒚≠𝒙 且𝑯(𝒚)=𝑯(𝒙)的𝒚，在计算上不可行，即已知一个明文与其哈希值，不能找到另一个哈希值与这个已知明文的哈希值相等的明文
抗强碰撞（生日攻击） 找到任何满足𝑯(𝒚)=𝑯(𝒙)的偶对(𝒙,𝒚)，在计算上不可行，即不能同时找到两个消息而且它们的哈希值相等
抗原像
抗弱碰撞
抗强碰撞
Hash数字签名
Y
Y
Y
入侵检测、病毒检测
Y
单向口令文件
Y
\begin{array}{|c|c|c|c|} \hline & \text { 抗原像 } & \text { 抗弱碰撞 } & \text { 抗强碰撞 } \\ \hline \text { Hash数字签名 } & Y & Y & Y \\ \hline \text { 入侵检测、病毒检测 } & & Y & \\ \hline \text { 单向口令文件 } & Y & & \\ \hline \end{array}
Hash数字签名 入侵检测、病毒检测 单向口令文件 抗原像 YY 抗弱碰撞 YY 抗强碰撞 Y
🕒 5. 攻击
🕘 5.1 穷举攻击
原像攻击、弱碰撞攻击
𝑯
(
𝒚
)
=
𝒉
𝟐
𝒎
−
𝟏
𝑯(𝒚)=𝒉 \\ 𝟐^{𝒎−𝟏}
H(y)=h2m−1
对Hash函数发起穷举攻击，不依赖于任何算法细节，仅与 Hash值长度𝒎 有关攻击者对给定的Hash值𝒉，随机选择𝒚并计算其Hash值，直到𝑯(𝒚)=𝒉 ，穷举规模𝟐𝒎，平均尝试𝟐𝒎−𝟏
碰撞攻击
𝑯
(
𝒙
)
=
𝑯
(
𝒚
)
𝟐
𝒎
/
𝟐
𝑯(𝒙)=𝑯(𝒚) \\ 𝟐^{𝒎/𝟐}
H(x)=H(y)2m/2
攻击者随机选择数据𝒙、𝒚，满足𝑯(𝒙)=𝑯(𝒚)对于𝒎位的Hash值，预计在
2
m
=
2
m
/
2
\sqrt{2^{m}}=2^{m / 2}
2m
=2m/2次尝试后就会出现碰撞
𝑯
(
𝒙
)
=
𝑯
(
𝒚
)
𝟐
128
/
𝟐
𝑯(𝒙)=𝑯(𝒚) \\ 𝟐^{128/𝟐}
H(x)=H(y)2128/2
𝟐
𝒎
/
𝟐
𝟐^{𝒎/𝟐}
2m/2决定了该Hash函数 抗穷举攻击 的强度Van Oosrschort等人斥巨资为128位的MD5设计了碰撞机，在24天内找到了一个碰撞
𝑯
(
𝒙
)
=
𝑯
(
𝒚
)
𝟐
80
𝑯(𝒙)=𝑯(𝒚) \\ 𝟐^{80}
H(x)=H(y)280
若 MD5值 变为160位，相同的碰撞机则需要4000年才可找出一个碰撞
而我国著名密码学家、中科院院士、2019未来科学大奖获得者、清华大学教授王小云 研究的MD5碰撞算法，将碰撞次数从
𝟐
𝟖
𝟎
𝟐^{𝟖𝟎}
280降低为
𝟐
𝟔
𝟗
\color{red}𝟐^{𝟔𝟗}
269
强碰撞的应用——生日悖论
🔎 生日悖论 同一天生日的问题，反直觉概率， 同月同日生不是难事
生日悖论视频
步骤一
发送方A 准备对 消息x 进行签名对消息x 进行Hash值计算，用A的私钥 对m位的 Hash值 加密，并将 加密的Hash值 附在 消息x 后
步骤二
攻击者产生消息𝒙 的
𝟐
𝒎
/
𝟐
𝟐^{𝒎/𝟐}
2m/2 种变式
𝒙
′
𝒙^′
x′，它们与𝒙表达相同的意义，将 所有
𝒙
′
𝒙^′
x′ 及其 Hash值 存储起来
步骤三
攻击者伪造消息𝒚 以及变式
𝒚
′
𝒚^′
y′，对每一个
𝒚
′
𝒚^′
y′ 计算 Hash值
𝑯
(
𝒚
′
)
𝑯(𝒚^′)
H(y′) ，并与
𝑯
(
𝒙
′
)
𝑯(𝒙^′)
H(x′) 进行对比，直到
𝑯
(
𝒚
′
)
=
𝑯
(
𝒙
′
)
𝑯(𝒚^′ )=𝑯(𝒙^′)
H(y′)=H(x′)
步骤四
攻击者将变式
𝒙
′
𝒙^′
x′ 提供给A 进行签名，将该签名附加在伪造的
𝒚
′
𝒚^′
y′之后发送给接收方由于
𝑯
(
𝒚
′
)
=
𝑯
(
𝒙
′
)
𝑯(𝒚^′ )=𝑯(𝒙^′)
H(y′)=H(x′) ，所以数字签名也是相同的
🕘 5.2 密码分析
对Hash函数发起密码分析攻击，依赖的是具体算法的设计缺点典型Hash函数的总体结构如下所示，包括SHA在内的大多数Hash函数都是这种迭代结构
将输入消息分为
L
L
L个固定长度的分组，每个分组长
b
b
b位
最后一个分组不足
b
b
b位，要加上填充内容
P
P
P与消息长度
Hash结构重复使用了函数𝒇
将第一个分组
𝒀
𝟎
\color{purple}𝒀_𝟎
Y0 和 初始化变量
𝑪
𝑽
𝟎
\color{green}𝑪𝑽_𝟎
CV0 输入到函数
f
\color{red}f
f中，输出一个
n
n
n位分组
𝑪
𝑽
𝟏
\color{green}𝑪𝑽_𝟏
CV1
将下一个分组
𝒀
𝟏
\color{purple}𝒀_𝟏
Y1 和 上一次输出
𝑪
𝑽
𝟏
\color{green}𝑪𝑽_𝟏
CV1 输入到函数
f
\color{red}f
f中，输出一个
n
n
n位分组
𝑪
𝑽
𝟐
\color{green}𝑪𝑽_𝟐
CV2
直到最后一个分组
𝒀
𝑳
−
𝟏
\color{purple}𝒀_{𝑳−𝟏}
YL−1 和 上一次输出
𝑪
𝑽
𝑳
−
𝟏
\color{green}𝑪𝑽_{𝑳−𝟏}
CVL−1 输入到函数
f
\color{red}f
f中，输出最终的Hash值，即分组
𝑪
𝑽
𝑳
\color{green}𝑪𝑽_𝑳
CVL
如果 迭代函数f 能够做到抗碰撞，那么Hash函数也会具有抗碰撞能力，密码分析就是分析
f
\color{red}f
f的内部结构
一个理想的Hash函数 要求密码分析所需的代价大于穷举攻击的代价
单选题： 原始消息的总长度是a位，将a位分成b位为一个分组，共L个分组。经过Hash函数的处理，输出Hash码为n位，问： Hash函数迭代结构中的初始值IV是多少位呢？ A.a B.b C.L D.n 答：选D
🕒 6. 安全Hash算法
安全Hash算法，简称SHA(Secure Hash Algorithm)，是使用最广泛的Hash函数，也是目前为止仅存的Hash算法标准
SHA系列算法 由NIST设计，初始版本为SHA-0，于1993年作为联邦信息处理标准发布
随后SHA-0被发现存在安全缺陷，将其修订后变为SHA-1并于1995年发布
SHA-1产生的是160位的Hash值
SHA算法建立在MD4算法之上，基本框架与MD4相似
2002年，NIST又给出了三种新的SHA版本，Hash值长度依次为256、384、512位，统称为SHA-2
SHA-2 的身影遍布在现今的各大Web应用之中
Sony PS4 与游戏服务器通信的数据，使用AES-128加密、CBC工作模式、SHA-256完整校验
XBOX ONE 与游戏服务器通信的数据，使用AES-256加密、CBC工作模式、SHA-384完整校验
2015年，NIST增加了两个算法SHA-512/224和SHA-512/256
我们将介绍SHA-2系列中的SHA-512，其他版本的算法与之类似
SHA-1
SHA-224
SHA-256
SHA-512
SHA-
512
/
224
SHA-
512
/
256
消息摘要长度（即哈希值长度）
160
224
256
512
224
256
消息长度
<
2
64
<
2
64
<
2
64
<
2
128
<
2
128
<
2
128
分组长度
512
512
512
1024
1024
1024
字长度
32
32
32
64
64
64
\begin{array}{|l|l|l|l|l|l|l|} \hline & \text { SHA-1 } & \text { SHA-224 } & \text { SHA-256 } & \text { SHA-512 } & \begin{array}{l} \text { SHA- } \\ 512 / 224 \end{array} & \begin{array}{l} \text { SHA- } \\ 512 / 256 \end{array} \\ \hline \text { 消息摘要长度（即哈希值长度）} & 160 & 224 & 256 & 512 & 224 & 256 \\ \hline \text { 消息长度 } & <2^{64} & <2^{64} & <2^{64} & <2^{128} & <2^{128} & <2^{128} \\ \hline \text { 分组长度 } & 512 & 512 & 512 & 1024 & 1024 & 1024 \\ \hline \text { 字长度 } & 32 & 32 & 32 & 64 & 64 & 64 \\ \hline \end{array}
消息摘要长度（即哈希值长度） 消息长度 分组长度 字长度 SHA-1 160<26451232 SHA-224 224<26451232 SHA-256 256<26451232 SHA-512 512<2128102464 SHA- 512/224224<2128102464 SHA- 512/256256<2128102464
🕒 7. SHA-512
🕘 7.1 附加填充位（步骤1）
要处理消息𝑴，长度𝑳 bits在消息𝑴后 增加 填充内容𝑷，使得填充后的长度
𝑳
𝑴
+
𝑳
𝑷
=
𝟖
𝟗
𝟔
(
𝒎
𝒐
𝒅
𝟏
𝟎
𝟐
𝟒
)
𝑳_𝑴+𝑳_𝑷=𝟖𝟗𝟔 (𝒎𝒐𝒅 𝟏𝟎𝟐𝟒)
LM+LP=896(mod1024)即使消息𝑴的长度已满足要求，仍需要进行填充填充的位数在 1~1024 之间，填充内容为1和一串连续0
单选题： 关于SHA-512的说法正确的是？ A. SHA-512产生的摘要长度是512位 B. SHA-512要求对消息进行填充，填充部分的长度可以为0bit. C. SHA-512还要求在消息的填充部分后加上256位的长度部分 D. SHA-512要求处理的分组长度是512位 答案：选A，摘要长度即哈希值长度；B错，不能为空；C错，是128位；D错，是1024位
🕘 7.2 附加长度位（步骤2）
在填充内容𝑷 之后附加一个128位的块，用来放消息𝑴的长度𝑳在该块中，将长度𝑳放在低位上，其余高位为空则放0经过填充，消息长度为
N
∗
1024
N*1024
N∗1024，将其划分为一个个1024位的分组
𝑴
𝟏
，
𝑴
𝟐
，
.
.
.
.
𝑴
𝑵
𝑴_𝟏，𝑴_𝟐，.... 𝑴_𝑵
M1，M2，....MN
练习： 使用SHA-512算法，计算消息36的Hash值，问： （1）消息长度是多少个bit？ （2）填充内容P 是什么？ （3）消息长度区域L 是什么？ 答： （1）
𝑴
=
𝟑
𝟔
𝑴=𝟑𝟔
M=36，化二进制为：100100，因此消息𝑴的长度是6个bit （2）
𝑳
𝑴
+
𝑳
𝑷
=
𝟖
𝟗
𝟔
(
𝒎
𝒐
𝒅
𝟏
𝟎
𝟐
𝟒
)
𝑳_𝑴+𝑳_𝑷=𝟖𝟗𝟔 (𝒎𝒐𝒅 𝟏𝟎𝟐𝟒)
LM+LP=896(mod1024)
𝟔
+
𝑳
𝑷
=
𝟖
𝟗
𝟔
(
𝒎
𝒐
𝒅
𝟏
𝟎
𝟐
𝟒
)
𝟔+𝑳_𝑷=𝟖𝟗𝟔 (𝒎𝒐𝒅 𝟏𝟎𝟐𝟒)
6+LP=896(mod1024)
𝑳
𝑷
=
𝟖
𝟗
𝟎
(
𝒎
𝒐
𝒅
𝟏
𝟎
𝟐
𝟒
)
=
𝒏
×
𝟏
𝟎
𝟐
𝟒
+
𝟖
𝟗
𝟎
𝑳_𝑷=𝟖𝟗𝟎 (𝒎𝒐𝒅 𝟏𝟎𝟐𝟒)=𝒏×𝟏𝟎𝟐𝟒+𝟖𝟗𝟎
LP=890(mod1024)=n×1024+890 令
𝑳
𝑷
=
𝟖
𝟗
𝟎
𝑳_𝑷=𝟖𝟗𝟎
LP=890（即n取0），填充内容
𝑷
𝑷
P：1和889个0 （3）
𝑴
=
𝟑
𝟔
𝑴=𝟑𝟔
M=36，继续填充 消息长度区域，消息长度为6，化为二进制110，将其放在 消息长度区域 的最低3位，其余高位填充为0，共128位 即消息长度区域为 125个0 和 110
🕘 7.3 缓冲区初始化（步骤3）
Hash函数的 中间结果 和 最终结果 都保存在一个512位的缓存区中512位缓存区 用8个64位的寄存器abcdefgh共同表示将寄存器abcdefgh 进行初始化，对前8个素数开平方，取小数部分的前64位
🕘 7.4 分组处理（步骤4）
SHA-512算法的核心是具有 80轮运算 的迭代函数F用函数F依次处理各分组，最终的输出即为消息的Hash
🕘 7.5 迭代函数F
迭代函数
F
F
F中的
𝑾
𝟎
、
𝑾
𝟏
…
𝑾
𝟕
𝟗
𝑾_𝟎 、 𝑾_𝟏 … 𝑾_{𝟕𝟗}
W0、W1…W79是什么呢？
σ
0
512
(
x
)
=
ROTR
1
(
x
)
⊕
ROTR
8
(
x
)
⊕
SHR
7
(
x
)
σ
1
512
(
x
)
=
ROTR
19
(
x
)
⊕
ROTR
61
(
x
)
⊕
SHR
6
(
x
)
\begin{aligned} \sigma_{0}^{512}(x) &=\operatorname{ROTR}^{1}(x) \oplus \operatorname{ROTR}^{8}(x) \oplus \operatorname{SHR}^{7}(x) \\ \sigma_{1}^{512}(x) &=\operatorname{ROTR}^{19}(x) \oplus \operatorname{ROTR}^{61}(x) \oplus \operatorname{SHR}^{6}(x) \end{aligned}
σ0512(x)σ1512(x)=ROTR1(x)⊕ROTR8(x)⊕SHR7(x)=ROTR19(x)⊕ROTR61(x)⊕SHR6(x)
𝑹
𝑶
𝑻
𝑹
𝒏
(
𝒙
)
𝑹𝑶𝑻𝑹^𝒏 (𝒙)
ROTRn(x)为对64位的变量
x
x
x循环右移
n
n
n位
𝑺
𝑯
𝑹
𝒏
(
𝒙
)
𝑺𝑯𝑹^𝒏 (𝒙)
SHRn(x)对64位的变量
x
x
x右移
n
n
n位，左边填充0
迭代函数
F
F
F中的
𝑲
𝟎
、
𝑲
𝟏
…
𝑲
𝟕
𝟗
𝑲_𝟎 、 𝑲_𝟏 … 𝑲_{𝟕𝟗}
K0、K1…K79又是什么呢？
SHA-512常数表
𝑲
𝟎
、
𝑲
𝟏
…
𝑲
𝟕
𝟗
𝑲_𝟎 、 𝑲_𝟏 … 𝑲_{𝟕𝟗}
K0、K1…K79是轮常量
🕤 7.5.1 F中的轮函数R
b
、
c
、
d
、
f
、
g
、
h
b、c、d、f、g、h
b、c、d、f、g、h直接由
a
、
b
、
c
、
e
、
f
、
g
a、b、c、e、f、g
a、b、c、e、f、g得到
T
1
=
h
+
Ch
(
e
,
f
,
g
)
+
(
∑
1
512
e
)
+
W
t
+
K
t
T_{1}= h+\operatorname{Ch}(e, f, g)+\left(\sum_{1}^{512} e\right)+W_{t}+K_{t}
T1=h+Ch(e,f,g)+(∑1512e)+Wt+Kt
T
2
=
(
∑
0
512
a
)
+
Maj
(
a
,
b
,
c
)
T_{2}=\left(\sum_{0}^{512} a\right)+\operatorname{Maj}(a, b, c)
T2=(∑0512a)+Maj(a,b,c)
e
=
d
+
T
1
e= d+T_{1}
e=d+T1
a
=
T
1
+
T
2
a= T_{1}+T_{2}
a=T1+T2
其中：
Ch
(
e
,
f
,
g
)
=
(
e AND
f
)
⨁
(
NOT e AND g)
\text { Ch }(e, f, g)=(\text { e AND } f) \bigoplus(\text { NOT e AND g) }
Ch (e,f,g)=( e AND f)⨁( NOT e AND g) 如果
e
e
e则
f
f
f，否则
g
g
g
Maj
(
a
,
b
,
c
)
=
(
a
AND b
)
⨁
(
a
AND c
)
⨁
(
b
AND c)
\operatorname{Maj}(a, b, c)=(a \text { AND b }) \bigoplus(a \text { AND c })\bigoplus(b \text { AND c) }
Maj(a,b,c)=(a AND b )⨁(a AND c )⨁(b AND c) 函数为真当且仅当变量的多数（2或3个）为真
(
∑
0
512
a
)
=
ROTR
28
(
a
)
⨁
ROTR
34
(
a
)
⨁
ROTR
39
(
a
)
\left(\sum_{0}^{512} a\right)= \operatorname{ROTR}^{28}(a) \bigoplus \operatorname{ROTR}^{34}(\mathrm{a}) \bigoplus \operatorname{ROTR}^{39}(\mathrm{a})
(∑0512a)=ROTR28(a)⨁ROTR34(a)⨁ROTR39(a)
(
∑
1
512
e
)
=
ROTR
14
(
e
)
⨁
ROTR
18
(
e
)
⨁
ROTR
41
(
e
)
\left(\sum_{1}^{512} e\right)= \operatorname{ROTR}^{14}(\mathrm{e}) \bigoplus \operatorname{ROTR}^{18}(\mathrm{e}) \bigoplus \operatorname{ROTR}^{41}(\mathrm{e})
(∑1512e)=ROTR14(e)⨁ROTR18(e)⨁ROTR41(e)
R
O
T
R
n
(
x
)
ROTR^n (x)
ROTRn(x)为对64位的变量
x
x
x循环右移
n
n
n位
单选题： 关于SHA-512的轮函数说法不正确的是？ A. 每个迭代函数包含了80轮的轮函数 B. 每个轮函数的输入有三部分，轮常量Kt，消息分组Mt和寄存器的值 C. 对于第一轮的轮函数，输入的是第一个消息分组的前32bit数据 D. 对于每轮轮函数，输出到寄存器b的值都是输入寄存器a的值 答案：选C，是64bit
🕒 8. SHA-512计算示例
a
b
c
\hspace{2cm}a\hspace{2cm}b\hspace{2cm}c
abc
97
98
99
\hspace{1.9cm}97\hspace{1.9cm}98\hspace{1.8cm}99
979899
01100001
01100010
01100011
\hspace{1.4cm}01100001\hspace{0.8cm}01100010\hspace{0.8cm}01100011
011000010110001001100011
假设对三个ASCII字符“abc”进行Hash首先将消息化为24位二进制比特串消息长度L=24，消息要被填充为mod1024下与896同余，简单起见就取为896故填充长度为896-24=872位，即1个“1”带着871个“0”
6162638000000000
0000000000000000
0000000000000000
0000000000000000
6162638000000000 \ 0000000000000000 \ 0000000000000000 \ 0000000000000000
6162638000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000 \ 0000000000000000 \ 0000000000000000 \ 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000000 \ 0000000000000000 \ 0000000000000000 \ 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000
0000000000000000
0000000000000000
0000000000000018
0000000000000000 \ 0000000000000000 \ 0000000000000000 \ 0000000000000018
0000000000000000 0000000000000000 0000000000000000 0000000000000018
将填充内容1000…00拼接在消息后面，再将消息长度00…0011000 拼接在填充内容后面构成的完整1024位消息分块的十六进制如上所示，分为16个64位字
W
0
=
6162638000000000
W
8
=
0000000000000000
W_0 = 6162638000000000 \quad W_8 = 0000000000000000
W0=6162638000000000W8=0000000000000000
W
1
=
0000000000000000
W
9
=
0000000000000000
W_1 = 0000000000000000 \quad W_9 = 0000000000000000
W1=0000000000000000W9=0000000000000000
W
2
=
0000000000000000
W
10
=
0000000000000000
W_2 = 0000000000000000 \quad W_{10} = 0000000000000000
W2=0000000000000000W10=0000000000000000
W
3
=
0000000000000000
W
11
=
0000000000000000
W_3 = 0000000000000000 \quad W_{11} = 0000000000000000
W3=0000000000000000W11=0000000000000000
W
4
=
0000000000000000
W
12
=
0000000000000000
W_4 = 0000000000000000 \quad W_{12} = 0000000000000000
W4=0000000000000000W12=0000000000000000
W
5
=
0000000000000000
W
13
=
0000000000000000
W_5 = 0000000000000000 \quad W_{13} = 0000000000000000
W5=0000000000000000W13=0000000000000000
W
6
=
0000000000000000
W
14
=
0000000000000000
W_6 = 0000000000000000 \quad W_{14} = 0000000000000000
W6=0000000000000000W14=0000000000000000
W
7
=
0000000000000000
W
15
=
0000000000000018
W_7 = 0000000000000000 \quad W_{15} = 0000000000000018
W7=0000000000000000W15=0000000000000018
在消息扩展过程中，该数据块的各个字被分别赋值给
𝑾
𝟎
、
𝑾
𝟏
、
.
.
.
.
𝑾
𝟏
𝟓
𝑾_𝟎、𝑾_𝟏、.... 𝑾_{𝟏𝟓}
W0、W1、....W15而参与运算的其余
𝑾
𝟏
𝟔
、
𝑾
𝟏
𝟕
、
.
.
.
𝑾
𝟕
𝟗
𝑾_{𝟏𝟔}、𝑾_{𝟏𝟕}、... 𝑾_{𝟕𝟗}
W16、W17、...W79可计算得到
a
6
a
09
e
667
f
3
b
c
c
908
f
6
a
f
c
e
b
8
b
c
f
c
d
d
f
5
1320
f
8
c
9
f
b
872
c
c
0
b
b
b
67
a
e
8584
c
a
a
73
b
6
a
09
e
667
f
3
b
c
c
908
f
6
a
f
c
e
b
8
b
c
f
c
d
d
f
5
c
3
c
6
e
f
372
f
e
94
f
82
b
b
b
67
a
e
8584
c
a
a
73
b
6
a
09
e
667
f
3
b
c
c
908
d
a
54
f
f
53
a
5
f
1
d
36
f
1
3
c
6
e
f
372
f
e
94
f
82
b
b
b
67
a
e
8584
c
a
a
73
b
e
510
e
527
f
a
d
e
682
d
1
58
c
b
02347
a
b
51
f
91
c
3
d
4
e
b
f
d
48650
f
f
a
f
9
b
05688
c
2
b
3
e
6
c
1
f
510
e
527
f
a
d
e
682
d
1
58
c
b
02347
a
b
51
f
91
g
1
f
83
d
9
a
b
f
b
41
b
d
6
b
9
b
05688
c
2
b
3
e
6
c
1
f
510
e
527
f
a
d
e
682
d
1
h
5
b
e
0
c
d
19137
e
2179
1
f
83
d
9
a
b
f
b
41
b
d
6
b
9
b
05688
c
2
b
3
e
6
c
1
f
\begin{array}{|c|c|c|l|} \hline a & 6 a 09 e 667 f 3 b c c 908 & f 6 a f c e b 8 b c f c d d f 5 & 1320 f 8 c 9 f b 872 c c 0 \\ b & bb67ae8584caa73b & 6 a 09 e 667 f 3 b c c 908 & f 6 a f c e b 8 b c f c d d f 5 \\ c & 3 c 6 e f 372 f e 94 f 82 b & b b 67 a e 8584 c a a 73 b & 6 a 09 e 667 f 3 b c c 908 \\ d & a54ff53a5f1d36f1 & 3 c 6 e f 372 f e 94 f 82 b & bb67ae8584caa73b \\ e & 510 e 527 f a d e 682 d 1 & 58 c b 02347 a b 51 f 91 & c3d4ebfd48650ffa \\ f & 9 b 05688 c 2 b 3 e 6 c 1 f & 510 e 527 f a d e 682 d 1 & 58 c b 02347 a b 51 f 91 \\ g & 1 f 83 d 9 a b f b 41 b d 6 b & 9 b 05688 c 2 b 3 e 6 c 1 f & 510 e 527 f a d e 682 d 1 \\ h & 5 b e 0 c d 19137 e 2179 & 1 f 83 d 9 a b f b 41 b d 6 b & 9 b 05688 c 2 b 3 e 6 c 1 f \\ \hline \end{array}
abcdefgh6a09e667f3bcc908bb67ae8584caa73b3c6ef372fe94f82ba54ff53a5f1d36f1510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b5be0cd19137e2179f6afceb8bcfcddf56a09e667f3bcc908bb67ae8584caa73b3c6ef372fe94f82b58cb02347ab51f91510e527fade682d19b05688c2b3e6c1f1f83d9abfb41bd6b1320f8c9fb872cc0f6afceb8bcfcddf56a09e667f3bcc908bb67ae8584caa73bc3d4ebfd48650ffa58cb02347ab51f91510e527fade682d19b05688c2b3e6c1f
8个寄存器
a
b
c
d
e
f
g
h
abcdefgh
abcdefgh的初始值为第一列，将其分别赋值给
𝑯
𝟎
,
𝟎
、
𝑯
𝟎
,
𝟏
、
.
.
.
.
𝑯
𝟎
,
𝟕
𝑯_{𝟎,𝟎}、𝑯_{𝟎,𝟏}、....𝑯_{𝟎,𝟕}
H0,0、H0,1、....H0,7右两列为经过两轮处理后的寄存器的值
H
1
,
0
=
6
a
09
e
667
f
3
b
c
c
908
+
73
a
54
f
399
f
a
4
b
1
b
2
=
d
d
a
f
35
a
193617
a
b
a
H_{1,0} = 6a09e667f3bcc908 + 73a54f399fa4b1b2 = ddaf35a193617aba
H1,0=6a09e667f3bcc908+73a54f399fa4b1b2=ddaf35a193617aba
H
1
,
1
=
b
b
67
a
e
8584
c
a
a
73
b
+
10
d
9
c
4
c
4295599
f
6
=
c
c
417349
a
e
204131
H_{1,1} = bb67ae8584caa73b + 10d9c4c4295599f6 = cc417349ae204131
H1,1=bb67ae8584caa73b+10d9c4c4295599f6=cc417349ae204131
H
1
,
2
=
3
c
6
e
f
372
f
e
94
f
82
b
+
d
67806
d
b
8
b
148677
=
12
e
6
f
a
4
e
89
a
97
e
a
2
H_{1,2} = 3c6ef372fe94f82b + d67806db8b148677 = 12e6fa4e89a97ea2
H1,2=3c6ef372fe94f82b+d67806db8b148677=12e6fa4e89a97ea2
H
1
,
3
=
a
54
f
f
53
a
5
f
1
d
36
f
1
+
654
e
f
9
a
b
e
c
389
c
a
9
=
0
a
9
e
e
e
e
64
b
55
d
39
a
H_{1,3} = a54ff53a5f1d36f1 + 654ef9abec389ca9 = 0a9eeee64b55d39a
H1,3=a54ff53a5f1d36f1+654ef9abec389ca9=0a9eeee64b55d39a
H
1
,
4
=
510
e
527
f
a
d
e
682
d
1
+
d
08446
a
a
79693
e
d
7
=
2192992
a
274
f
c
1
a
8
H_{1,4} = 510e527fade682d1 + d08446aa79693ed7 = 2192992a274fc1a8
H1,4=510e527fade682d1+d08446aa79693ed7=2192992a274fc1a8
H
1
,
5
=
9
b
05688
c
2
b
3
e
6
c
1
f
+
9
b
b
4
d
39778
c
07
f
9
e
=
36
b
a
3
c
23
a
3
f
e
e
b
b
d
H_{1,5} = 9b05688c2b3e6c1f + 9bb4d39778c07f9e = 36ba3c23a3feebbd
H1,5=9b05688c2b3e6c1f+9bb4d39778c07f9e=36ba3c23a3feebbd
H
1
,
6
=
1
f
83
d
9
a
b
f
b
41
b
d
6
b
+
25
c
96
a
7768
f
b
2
a
a
3
=
454
d
4423643
c
e
80
e
H_{1,6} = 1f83d9abfb41bd6b + 25c96a7768fb2aa3 = 454d4423643ce80e
H1,6=1f83d9abfb41bd6b+25c96a7768fb2aa3=454d4423643ce80e
H
1
,
7
=
5
b
e
0
c
d
19137
e
2179
+
c
e
b
9
f
c
3691
c
e
8326
=
2
a
9
a
c
94
f
a
54
c
a
49
f
H_{1,7} = 5be0cd19137e2179 + ceb9fc3691ce8326 = 2a9ac94fa54ca49f
H1,7=5be0cd19137e2179+ceb9fc3691ce8326=2a9ac94fa54ca49f
d
d
a
f
35
a
193617
a
b
a
c
c
417349
a
e
204131
12
e
6
f
a
4
e
89
a
97
e
a
2
0
a
9
e
e
e
e
64
b
55
d
39
a
ddaf35a193617aba \ cc417349ae204131 \ 12e6fa4e89a97ea2 \ 0a9eeee64b55d39a
ddaf35a193617aba cc417349ae204131 12e6fa4e89a97ea2 0a9eeee64b55d39a
2192992
a
274
f
c
1
a
8
36
b
a
3
c
23
a
3
f
e
e
b
b
d
454
d
4423643
c
e
80
e
2
a
9
a
c
94
f
a
54
c
a
49
f
2192992a274fc1a8 \ 36ba3c23a3feebbd \ 454d4423643ce80e \ 2a9ac94fa54ca49f
2192992a274fc1a8 36ba3c23a3feebbd 454d4423643ce80e 2a9ac94fa54ca49f
如上过程重复80轮后，最终得到512位的消息摘要
假设将输入消息改变1位，从“abc”变成“cbc”，对应的512位消息摘要发生了253位不同
d
d
a
f
35
a
193617
a
b
a
c
c
417349
a
e
204131
12
e
6
f
a
4
e
89
a
97
e
a
2
0
a
9
e
e
e
e
64
b
55
d
39
a
ddaf35a193617aba \ cc417349ae204131 \ 12e6fa4e89a97ea2 \ 0a9eeee64b55d39a
ddaf35a193617aba cc417349ae204131 12e6fa4e89a97ea2 0a9eeee64b55d39a
2192992
a
274
f
c
1
a
8
36
b
a
3
c
23
a
3
f
e
e
b
b
d
454
d
4423643
c
e
80
e
2
a
9
a
c
94
f
a
54
c
a
49
f
2192992a274fc1a8 \ 36ba3c23a3feebbd \ 454d4423643ce80e \ 2a9ac94fa54ca49f
2192992a274fc1a8 36ba3c23a3feebbd 454d4423643ce80e 2a9ac94fa54ca49f
即SHA-512 具有良好的雪崩效应
OK，以上就是本期知识点“哈希函数”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟📌~ 💫如果有错误❌，欢迎批评指正呀👀~让我们一起相互进步🚀 🎉如果觉得收获满满，可以点点赞👍支持一下哟~
❗ 转载请注明出处 作者：HinsCoder 博客链接：🔎 作者博客主页