1.SHA简介
/ O% c9 @1 u8 L关于SHA的定义直接参考wiki介绍：* _6 x& o  y0 ]) ^
安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。7 j% Z, h1 E5 x% b
SHA可看作是是一种单向函数，几乎不可逆，给一段信息，它会给你生成固定长度的摘要，当然，不同的信息是的确有可能生成相同的摘要的，这被称作碰撞，简单来说，摘要的长度越长，碰撞几率越低。
3 g$ m9 N7 I& O既然有碰撞这种可能性，那碰撞肯定会被拿来用作攻击手段的，SHA-1已经在17年被Google和荷兰的小组攻破了，目前使用的标准是SHA-2，其实在算法上SHA-2和SHA-1区别不大，但是至今SHA-2还没被攻破，所以暂且当它没什么弱点。
$ v. w2 E3 B# O5 M* |从SHA的特点来看，用来作文件验证和数字签名是非常合适的。比特币使用的就是SHA-2中的SHA256算法。
; J- F, [& T8 H" o, c5 }  ^2.SHA256的算法实现
3 T; {! S! {: q+ D& n/ m首先，SHA算法在数学原理上是相当复杂的（那些移位与或非对于算法的作用看着就头大），对于不以密码学研究为目的，同时也是初学者的我来说，去分析它的数学细节对我没有什么意义，因此我暂且忽略那一部分直接看它的算法实现。
$ w+ Z7 z$ T- }实现可以分为三个部分：常量初始化，信息预处理，生成摘要。
6 R9 A; B5 E" C9 X5 Q) o2 t  {2.1常量初始化1 i% H5 V8 p0 ^3 Q9 E, E# |1 c4 ]1 g
首先是初始化8个值，分别是最开始的连续8个素数（从2到19）的平方根的二进制表示的小数部分的前32位，有点绕，不过就是这样啦，这些后面会作为迭代的初值使用。( r" w4 V" y* |" |% T8 t) Q
Initialize variables
# r2 e: q. ^. Z, H(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):) O. h- K( E$ ^* |
h0 := 0x6a09e667+ |* p2 B/ U- B# _8 ]. a
h1 := 0xbb67ae85
6 @/ L. F) t/ s4 oh2 := 0x3c6ef372
! H& d3 B8 [- J( nh3 := 0xa54ff53a6 W3 |6 v+ a+ a: l, l) e+ F
h4 := 0x510e527f8 t1 X. n8 m" q1 A- S& w; G+ k
h5 := 0x9b05688c6 l$ A% v! A8 N
h6 := 0x1f83d9ab
4 J* ]+ H+ m, {$ f# I+ S2 \h7 := 0x5be0cd19
" S: _8 k7 x+ c然后还要初始化64个值，分别是最开始的连续64个素数（从2到311）的立方根的二进制表示的小数部分的前32位，可以看到这64个数也成了数组的形式，因为是要在后面每次迭代中拿来进行循环运算的。2 l6 }' I* w( h6 h! D3 i6 M
Initialize table of round constants
7 K9 f) X" \9 ?(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):0 r1 S5 _8 ]& `4 Z
k[0..63] :=+ P( E( R, ?# e1 v8 y
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,( \: y: c+ D+ ^, @+ O/ C
   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
1 k" M$ ~) C% U; A   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
, P/ u* t: \0 ]; S   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,% h5 l9 @4 T4 d% s' b9 t
   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
7 Z- O9 `) N: Q9 Z   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,9 |' y: T- ]! @7 m, z* I, P: D
   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,; ~& p7 [2 s) k7 R8 R( J
   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
) W5 ?8 x3 ^8 p; x$ y* D' H9 C2.2信息预处理
& b0 ?, h- Z5 B. u8 c预处理分为三步，首先是在原信息后加一个‘1’；然后再添加k个0，直到信息长度 mod 512 = 448，如果原信息是447这种长度，那其实就不用加0了；最后就是再添加原信息的长度到末尾，是64位的大端模式的格式。
7 |1 r- X; K$ |% U/ NPre-processing:
* e8 x. u' G8 bappend the bit '1' to the message, L6 I% |2 U1 @, Q; Z
append k bits '0', where k is the minimum number >= 0 such that the resulting message* A' \8 o( a5 Q6 p+ v  k7 ]
    length (in bits) is congruent to 448(mod 512): B0 b# d, O7 b5 p: T+ Y3 Z
append length of message (before pre-processing), in bits, as 64-bit big-endian integer
$ Y( O' o7 o+ A2.3生成摘要
+ V/ D4 y1 @  f, b到了最麻烦的一步了，生成摘要。/ J5 p3 a, j! v: }$ S$ z# M6 ^
首先，经过第二步，现在信息已经是512bit的倍数这种格式了，所以这里首先是把信息分成块，每一块是512bit，然后每一块都是一次迭代，每一次迭代都会更新摘要，最后一次迭代结果就是最终生成的摘要。
, k& z1 m6 j! R* {所以，关键就是每一步迭代过程中发生了什么。9 f6 M; C4 L, P
对于SHA256算法，最终的摘要是256bit的，结合前面的8个32bit的初值，这里就不难理解了，总的摘要是分成8个值进行更新的。块大小是512bit的，将其也以32bit为单位分成16个，然后通过对16个数进行运算，生成另外48个数，总之，得到了64个值，这和前面的64个常量相对应，剩下的就直接看下图吧：
6 F; ?# i4 K3 p( R* }; F
7 \; E" y  M. `; E* @& B每次迭代摘要的更新流程
5 D, |7 j/ d9 F% Y1 c1 C  N中间各种运算符什么的，就是一些运算而已，没什么好说的， W是从块中得到的64个数的集合，K是之前初始化的64个数的集合，可以看到一次迭代内部有64次循环，每次循环都会更新一次摘要。7 M8 Y" B8 {% H( G( J# ~- ~' H1 \0 e$ j
最后，来看看伪代码把：
: U4 P4 d# L+ o( h/ a7 {Process the message in successive 512-bit chunks:
8 O! w+ `! C& i# Ibreak message into 512-bit chunks
( g4 z  J& y$ v  C* l9 C3 [for each chunk9 j6 G/ q, f# v. G: }: n9 @
    break chunk into sixteen 32-bit big-endian words w[0..15]
! L) ]  I8 q7 X& W    Extend the sixteen 32-bit words into sixty-four 32-bit words:$ |& t( ?7 s! k: j% Q
    for i from 16 to 63# g0 D  \; F1 V# Y: @9 K
        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3)0 `. J1 T5 \7 c9 u& H
        s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10)! \8 G2 A8 w( M# i
        w := w[i-16] + s0 + w[i-7] + s1
- O7 }( t$ `: l! \: P    Initialize hash value for this chunk:9 T( _2 T. D) l6 j0 n  Q" e6 @3 N2 h
    a := h0
8 V4 D7 J6 ?/ Y1 b! L4 {    b := h1
9 x% f! b" t6 y7 K- B$ A4 t. G' o    c := h2
: `' ]1 ^& j% T7 J# }8 F    d := h3- w4 A$ t! v0 x' ^
    e := h4
% M- C' x6 b8 @' H    f := h5
, k0 ^2 l2 Y" s: ]6 ]' b    g := h6( o' Z, p% Z7 g2 J! Q
    h := h7+ L# X( m9 E4 i5 M5 H2 O
    Main loop:0 U' m* ~! s9 j6 K! z  V: D
    for i from 0 to 63+ r7 R; N7 x7 P
        s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22); S, r6 V  j' F
        maj := (a and b) xor (a and c) xor(b and c)
5 ~( N+ a" |# S, x% w* b' W$ I6 g6 d        t2 := s0 + maj" _; E7 ]1 {$ g- v
        s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)6 a: U" s+ n) \9 i
        ch := (e and f) xor ((not e) and g)
* A' ^: R1 {( V8 f8 C( L+ w! `        t1 := h + s1 + ch + k + w) ?' C* Y* G2 q" ?( V2 F2 I! C
        h := g
  J# Y: b" P/ W' Z( A! T: F        g := f
2 e9 U1 |1 U% H9 U        f := e" J  A; ~; w' L, T2 x
        e := d + t1
7 C. a" ]) o  i, v        d := c; _. M7 |( X$ v% u; j7 _
        c := b( m1 E! \2 c; c. C" S& y; p
        b := a
5 ?, \) c" B. W$ ?( U  s8 n        a := t1 + t20 n7 [9 o" c! ~1 o9 @
    Add this chunk's hash to result so far:
/ I& l6 |/ V2 H6 b6 S# ?8 J    h0 := h0 + a
  _% x' B7 `2 e% a% Z/ ]    h1 := h1 + b: K* j2 ]. r! f
    h2 := h2 + c% V6 Y! x# {0 @. L/ W
    h3 := h3 + d
) ~2 G# K9 T4 ]3 ]! X  t    h4 := h4 + e: f. h' H; Z' S0 p- u' r
    h5 := h5 + f
4 n6 v5 X) }4 E    h6 := h6 + g. |; D) n- L5 t2 e$ t9 d
    h7 := h7 + h
6 M1 z" x( p( ~5 PProduce the final hash value (big-endian):: M! c+ q0 t9 G
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h71 n# _5 r9 r' G4 x
一目了然，对吧。
# G  E$ n) M7 K7 t% D; q6 @; n5 u