SHA 算法的原理及实现

章节目录

1. 简介
2. 算法描述
   2.1 数据准备
   2.1.1 数据填充
   2.1.2 数据分块
   2.1.3 设置初始 Hash 值
   2.2 Hash 计算
   2.2.1 SHA-1
   2.2.2 SHA-256
   2.2.3 SHA-512
3. 实现

作者能力有限, 如果您在阅读过程中发现任何错误, 还请您务必联系本人,指出错误, 避免后来读者再学习错误的知识.谢谢!

简介##

SHA 算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。

本文我们将介绍以下 SHA 算法: SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256.

其中 SHA-224 和 SHA-256 使用相同的算法, 区别在于初始 Hash 值不同, 最终结果只使用算法输出的数据中的前224/256 bit.
SHA-384, SHA-512, SHA-512/224, SHA-512/256 使用相同的算法, 区别在于初始 Hash 值不同, 最终结果只使用算法输出的数据中的前384/512/224/256 bit.
而 SHA-2* 和 SHA-384,SHA-5* 算法也非常类似, 区别在于采用的字(Word) 长度不同, SHA-2*使用 32-bit 的字, 而 其他算法使用 64-bit 的字. 算法的迭代次数也不一样.

算法描述##

本文中将介绍的 SHA 算法的计算步骤从大体上可以分为两步: 数据准备 和 Hash 计算.

数据准备###

在数据准备阶段, 我们也像 MD5 那样, 需要先将数据填充到特定长度,同时将原始数据长度填充进去,然后对数据进行分块, 因为我们的算法是基于块进行的. SHA 家族中的具体算法的实现大体相同, 只是填充长度的bit数,分块大小略有不同而已.

在数据准备阶段我们需要进行三个操作: 数据填充, 数据分块, 设置初始 Hash 值.

数据填充####

我们使用 $M$ 表示数据数据, 它的长度使用 $l$ 表示.

对于算法 SHA-1, SHA-224, SHA-256, 数据填充方法如下:
先填充 1 bit 的 ‘1’ 到数据末尾, 然后紧接着填充 k 个 ‘0’, 这里 k 需要时最小的非负数且满足 $l+1+k\equiv 448mod512$, 也即是说需要将原始数据长度填充到差64位就是512的整数倍.
上述操作结束后, 将 $l$ 表示为 64 bit 的bit数组填充到上述步骤所得的数据之后, 此时我们得到一个长度为512整数倍的数据.

举个例子:
假设我们的数据数据为"abc", 它的长度为24(bit). 我们通过计算得到 k 应该是 423(448 - 1 - 24). 此时填充之后的数据应该如下:
$$\underset{a}{\underbrace{01100001}}\underset{b}{\underbrace{01100010}}\underset{c}{\underbrace{01100011}}1\stackrel{423}{\overbrace{00...00}}\stackrel{64}{\overbrace{00...0\underset{t=24}{\underbrace{11000}}}}$$
填充完成之后的长度是512(bit).

对于算法 SHA-384, SHA-512, SHA-512/224, SHA-512/256, 数据填充方法如下:
先填充 1 bit 的 ‘1’ 到数据末尾, 然后紧接着填充 k 个 ‘0’, 这里 k 需要时最小的非负数且满足 $l+1+k\equiv 896mod1024$, 也即是说需要将原始数据长度填充到差128位就是1024的整数倍.
上述操作结束后, 将 $l$ 表示为 128 bit 的bit数组填充到上述步骤所得的数据之后, 此时我们得到一个长度为1024整数倍的数据.

以上述的例子为例:
假设我们的数据数据为"abc", 它的长度为24(bit). 我们通过计算得到 k 应该是 871(896 - 1 - 24). 此时填充之后的数据应该如下:
$$\underset{a}{\underbrace{01100001}}\underset{b}{\underbrace{01100010}}\underset{c}{\underbrace{01100011}}1\stackrel{871}{\overbrace{00...00}}\stackrel{128}{\overbrace{00...0\underset{t=24}{\underbrace{11000}}}}$$
填充完成之后的长度是1024(bit).

数据分块####

填充后的数据需要被分块.

对于算法 SHA-1, SHA-224, SHA-256,
我们将数据分为 $N$ 个 521-bit 的块, 分别表示为
$$M^{(1)},M^{(2)},...,M^{(N)}$$
512-bit 的块又可以被划分为 16 个字(32-bit Word), 分别表示为
$$M_0^{(i)},M_1^{(i)},...,M_{15}^{(i)}$$

对于算法 SHA-384, SHA-512, SHA-512/224, SHA-512/256
我们将数据分为 $N$ 个 1024-bit 的块, 分别表示为
$$M^{(1)},M^{(2)},...,M^{(N)}$$
1024-bit 的块又可以被划分为 16 个字(64-bit Word), 分别表示为
$$M_0^{(i)},M_1^{(i)},...,M_{15}^{(i)}$$

设置初始 Hash 值####

每个特定的 SHA 算法, 都有相应的初始 Hash 值. 在计算 Hash 之前, 我们需要先将初始值准备好.

为了减少文章篇幅, 这里我们不列出这些初始值和 Hash 计算过程中使用到的常量$K$,后边算法实现中会给出相应数据.

Hash 计算###

SHA-1####

SHA-1 算法要求输入数据的长度不能大于 $2^{6}4$, 最小长度为0.

伪代码如下:

$ROT{L}^n(x)=(x<<n)\cup (x>>w-n)$

$f_t(x,y,z)$ = $$\{\begin{array}{l}Ch(x,y,z)=(x\cap y)⨁(\neg x\cap z),0\le t\le 19\\ \\ Parity(x,y,z)=x⨁y⨁z,20\le t\le 39\\ \\ Maj(x,y,z)=(x\cap y)⨁(x\cap z)⨁(y\cap z),40\le t\le 59\\ \\ Parity(x,y,z)=x⨁y⨁z,60\le t\le 79\\ \end{array}$$

For i=1 to N:
{
    //1. 计算 $W_t$
$W_t$ = $$\{\begin{array}{l}{M}_t^{(0)},0\le t\le 15\\ \\ ROT{L}^1(W_{t-3}⨁W_{t-8}⨁W_{t-14}⨁W_{t-16}),16\le t\le 79\end{array}$$

    //2. 初始化工作变量 a, b, c, d, e. 他们用来存储在第 i-1 次迭代式的 Hash 值
    // 他们的初始值就是我们在"设置初始 Hash 值"小节中所说的值.
$$\begin{gathered} a=H_0^{i-1} \\ b=H_1^{i-1} \\ c=H_2^{i-1} \\ d=H_3^{i-1} \\ e=H_4^{i-1} \end{gathered}$$

    // 3
    For t=0 to 79:
    {
$$\begin{gathered} T=ROT{L}^5(a)+f_t(b,c,d)+e+K_t+W_t \\ e=d \\ d=c \\ c=ROT{L}^{3}0(b) \\ b=a \\ a=T \end{gathered}$$
    }

    //4. 计算第 $i^{th}$ 中间 hash 值$H^i$
$$\begin{gathered} H_0^{(i)}=a+H_0^{(i-1)} \\ {H}_1^{(i)}=b+H_1^{(i-1)} \\ {H}_2^{(i)}=c+H_2^{(i-1)} \\ {H}_3^{(i)}=d+H_3^{(i-1)} \\ {H}_4^{(i)}=e+H_4^{(i-1)} \end{gathered}$$
}

在经过 N 次迭代之后, 最终结果为 $H_0^{(N)},H_1^{(N)},H_2^{(N)},H_3^{(N)},H_4^{(N)}$ 的字节表示依次连接所组成的字节数组.

SHA-256####

SHA-256 算法要求输入数据的长度不能大于 $2^{6}4$, 最小长度为0.

SHA-224 算法的计算过程与 SHA-256 相同, 却别在于使用的初始化 Hash 值不同, 且 SHA-224 算法的最终结果是取 SHA-256 算法结果的前 224 bit.

伪代码如下:

$SH{R}^n(x)=x>>n$
$ROT{R}^n(x)=(x>>n)\cup (x<<w-n)$
Σ0{256}(x)=ROTR2(x)⨁ROTR13(x)⨁ROTR22(x)\Sigma^{\{256\}}_0(x)=ROTR^2(x)\bigoplus ROTR^{13}(x)\bigoplus ROTR^{22}(x)Σ0{256}​(x)=ROTR2(x)⨁ROTR13(x)⨁ROTR22(x)
Σ1{256}(x)=ROTR6(x)⨁ROTR11(x)⨁ROTR25(x)\Sigma^{\{256\}}_1(x)=ROTR^6(x)\bigoplus ROTR^{11}(x)\bigoplus ROTR^{25}(x)Σ1{256}​(x)=ROTR6(x)⨁ROTR11(x)⨁ROTR25(x)
σ0{256}(x)=ROTR7(x)⨁ROTR18(x)⨁SHR3(x)\sigma^{\{256\}}_0(x)=ROTR^7(x)\bigoplus ROTR^{18}(x)\bigoplus SHR^3(x)σ0{256}​(x)=ROTR7(x)⨁ROTR18(x)⨁SHR3(x)
σ1{256}(x)=ROTR17(x)⨁ROTR19(x)⨁SHR10(x)\sigma^{\{256\}}_1(x)=ROTR^{17}(x)\bigoplus ROTR^{19}(x)\bigoplus SHR^{10}(x)σ1{256}​(x)=ROTR17(x)⨁ROTR19(x)⨁SHR10(x)

For i=1 to N:
{
    //1. 计算 $W_t$
$W_t$ = {Mt(0),0≤t≤15σ1{256}(Wt−2)+Wt−7+σ0{256}(Wt−15)+Wt−16,16≤t≤63\begin{cases} M^{(0)}_t, \qquad 0\leq t\leq15\\ \quad \\ \sigma^{\{256\}}_1(W_{t-2})+W_{t-7}+\sigma^{\{256\}}_0(W_{t-15})+W_{t-16}, \qquad 16\leq t\leq63\\ \end{cases}⎩⎪⎨⎪⎧​Mt(0)​,0≤t≤15σ1{256}​(Wt−2​)+Wt−7​+σ0{256}​(Wt−15​)+Wt−16​,16≤t≤63​

    //2. 初始化工作变量 a, b, c, d, e, f, g, h. 他们用来存储在第 i-1 次迭代式的 Hash 值
    // 他们的初始值就是我们在"设置初始 Hash 值"小节中所说的值.
$$\begin{gathered} a=H_0^{i-1} \\ b=H_1^{i-1} \\ c=H_2^{i-1} \\ d=H_3^{i-1} \\ e=H_4^{i-1} \\ f=H_5^{i-1} \\ g=H_6^{i-1} \\ h=H_7^{i-1} \end{gathered}$$

    // 3
    For t=0 to 63:
    {
T1=h+Σ1{256}(e)+Ch(e,f,g)+K{256}t+WtT2=Σ0{256}(a)+Maj(a,b,c)h=gg=ff=ee=d+T1d=cc=bb=aa=T1+T2\qquad T_1=h+\Sigma^{\{256\}}_1(e)+Ch(e,f,g)+K^{\{256\}_t}+W_t \\ \qquad T_2=\Sigma^{\{256\}}_0(a)+Maj(a,b,c) \\ \qquad h=g \\ \qquad g=f \\ \qquad f=e \\ \qquad e=d+T_1 \\ \qquad d=c \\ \qquad c=b \\ \qquad b=a \\ \qquad a=T_1+T_2 \\ T1​=h+Σ1{256}​(e)+Ch(e,f,g)+K{256}t​+Wt​T2​=Σ0{256}​(a)+Maj(a,b,c)h=gg=ff=ee=d+T1​d=cc=bb=aa=T1​+T2​
    }

    //4. 计算第 $i^{th}$ 中间 hash 值$H^i$
$$\begin{gathered} H_0^{(i)}=a+H_0^{(i-1)} \\ {H}_1^{(i)}=b+H_1^{(i-1)} \\ {H}_2^{(i)}=c+H_2^{(i-1)} \\ {H}_3^{(i)}=d+H_3^{(i-1)} \\ {H}_4^{(i)}=e+H_4^{(i-1)} \\ {H}_5^{(i)}=b+H_5^{(i-1)} \\ {H}_6^{(i)}=c+H_6^{(i-1)} \\ {H}_7^{(i)}=d+H_7^{(i-1)} \end{gathered}$$
}

在经过 N 次迭代之后, 最终结果为 $H_0^{(N)},H_1^{(N)},H_2^{(N)},H_3^{(N)},H_4^{(N)},H_5^{(N)},H_6^{(N)},H_7^{(N)}$ 的字节表示依次连接所组成的字节数组.

SHA-512####

SHA-512 算法要求输入数据的长度不能大于 $2^{1}28$, 最小长度为0.

SHA-384 算法的计算过程与 SHA-512 相同, 却别在于使用的初始化 Hash 值不同, 且 SHA-384 算法的最终结果是取 SHA-512 算法结果的前 384 bit.

SHA-512/224 算法的计算过程与 SHA-512 相同, 却别在于使用的初始化 Hash 值不同, 且 SHA-512/224 算法的最终结果是取 SHA-512 算法结果的前 224 bit.

SHA-512/256 算法的计算过程与 SHA-512 相同, 却别在于使用的初始化 Hash 值不同, 且 SHA-512/256 算法的最终结果是取 SHA-512 算法结果的前 256 bit.

伪代码如下:

Σ0{512}(x)=ROTR28(x)⨁ROTR34(x)⨁ROTR39(x)\Sigma^{\{512\}}_0(x)=ROTR^{28}(x)\bigoplus ROTR^{34}(x)\bigoplus ROTR^{39}(x)Σ0{512}​(x)=ROTR28(x)⨁ROTR34(x)⨁ROTR39(x)
Σ1{512}(x)=ROTR14(x)⨁ROTR18(x)⨁ROTR41(x)\Sigma^{\{512\}}_1(x)=ROTR^{14}(x)\bigoplus ROTR^{18}(x)\bigoplus ROTR^{41}(x)Σ1{512}​(x)=ROTR14(x)⨁ROTR18(x)⨁ROTR41(x)
σ0{512}(x)=ROTR1(x)⨁ROTR8(x)⨁SHR7(x)\sigma^{\{512\}}_0(x)=ROTR^1(x)\bigoplus ROTR^8(x)\bigoplus SHR^7(x)σ0{512}​(x)=ROTR1(x)⨁ROTR8(x)⨁SHR7(x)
σ1{512}(x)=ROTR19(x)⨁ROTR61(x)⨁SHR6(x)\sigma^{\{512\}}_1(x)=ROTR^{19}(x)\bigoplus ROTR^{61}(x)\bigoplus SHR^6(x)σ1{512}​(x)=ROTR19(x)⨁ROTR61(x)⨁SHR6(x)

For i=1 to N:
{
    //1. 计算 $W_t$
$W_t$ = {Mt(0),0≤t≤15σ1{512}(Wt−2)+Wt−7+σ0{512}(Wt−15)+Wt−16,16≤t≤79\begin{cases} M^{(0)}_t, \qquad 0\leq t\leq15\\ \quad \\ \sigma^{\{512\}}_1(W_{t-2})+W_{t-7}+\sigma^{\{512\}}_0(W_{t-15})+W_{t-16}, \qquad 16\leq t\leq79\\ \end{cases}⎩⎪⎨⎪⎧​Mt(0)​,0≤t≤15σ1{512}​(Wt−2​)+Wt−7​+σ0{512}​(Wt−15​)+Wt−16​,16≤t≤79​

    //2. 初始化工作变量 a, b, c, d, e, f, g, h. 他们用来存储在第 i-1 次迭代式的 Hash 值
    // 他们的初始值就是我们在"设置初始 Hash 值"小节中所说的值.
$$\begin{gathered} a=H_0^{i-1} \\ b=H_1^{i-1} \\ c=H_2^{i-1} \\ d=H_3^{i-1} \\ e=H_4^{i-1} \\ f=H_5^{i-1} \\ g=H_6^{i-1} \\ h=H_7^{i-1} \end{gathered}$$

    // 3
    For t=0 to 79:
    {
T1=h+Σ1{512}(e)+Ch(e,f,g)+K{512}t+WtT2=Σ0{512}(a)+Maj(a,b,c)h=gg=ff=ee=d+T1d=cc=bb=aa=T1+T2\qquad T_1=h+\Sigma^{\{512\}}_1(e)+Ch(e,f,g)+K^{\{512\}_t}+W_t \\ \qquad T_2=\Sigma^{\{512\}}_0(a)+Maj(a,b,c) \\ \qquad h=g \\ \qquad g=f \\ \qquad f=e \\ \qquad e=d+T_1 \\ \qquad d=c \\ \qquad c=b \\ \qquad b=a \\ \qquad a=T_1+T_2 \\ T1​=h+Σ1{512}​(e)+Ch(e,f,g)+K{512}t​+Wt​T2​=Σ0{512}​(a)+Maj(a,b,c)h=gg=ff=ee=d+T1​d=cc=bb=aa=T1​+T2​
    }

    //4. 计算第 $i^{th}$ 中间 hash 值$H^i$
$$\begin{gathered} H_0^{(i)}=a+H_0^{(i-1)} \\ {H}_1^{(i)}=b+H_1^{(i-1)} \\ {H}_2^{(i)}=c+H_2^{(i-1)} \\ {H}_3^{(i)}=d+H_3^{(i-1)} \\ {H}_4^{(i)}=e+H_4^{(i-1)} \\ {H}_5^{(i)}=b+H_5^{(i-1)} \\ {H}_6^{(i)}=c+H_6^{(i-1)} \\ {H}_7^{(i)}=d+H_7^{(i-1)} \end{gathered}$$
}

在经过 N 次迭代之后, 最终结果为 $H_0^{(N)},H_1^{(N)},H_2^{(N)},H_3^{(N)},H_4^{(N)},H_5^{(N)},H_6^{(N)},H_7^{(N)}$ 的字节表示依次连接所组成的字节数组.

算法实现##

本人使用 go 语言实现了该算法. github:https://github.com/UselezzProgrammer/mycrypto

END!