1.SHA简介* d5 W" |! \, Y' c4 Y: @
关于SHA的定义直接参考wiki介绍：  l4 U5 O0 Y9 R2 t7 v; `
安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。
) I2 }5 }, u9 V8 t( |SHA可看作是是一种单向函数，几乎不可逆，给一段信息，它会给你生成固定长度的摘要，当然，不同的信息是的确有可能生成相同的摘要的，这被称作碰撞，简单来说，摘要的长度越长，碰撞几率越低。  y, [. J' w$ s
既然有碰撞这种可能性，那碰撞肯定会被拿来用作攻击手段的，SHA-1已经在17年被Google和荷兰的小组攻破了，目前使用的标准是SHA-2，其实在算法上SHA-2和SHA-1区别不大，但是至今SHA-2还没被攻破，所以暂且当它没什么弱点。
2 K3 R4 ^. Q$ b. K从SHA的特点来看，用来作文件验证和数字签名是非常合适的。比特币使用的就是SHA-2中的SHA256算法。8 [: ?: S5 N4 W7 G
2.SHA256的算法实现& e/ E# X; S& R* C
首先，SHA算法在数学原理上是相当复杂的（那些移位与或非对于算法的作用看着就头大），对于不以密码学研究为目的，同时也是初学者的我来说，去分析它的数学细节对我没有什么意义，因此我暂且忽略那一部分直接看它的算法实现。* C6 y+ o/ `( m, X
实现可以分为三个部分：常量初始化，信息预处理，生成摘要。
8 ?9 X4 Q# i, ^' K2.1常量初始化, [" }+ A$ F, L: q
首先是初始化8个值，分别是最开始的连续8个素数（从2到19）的平方根的二进制表示的小数部分的前32位，有点绕，不过就是这样啦，这些后面会作为迭代的初值使用。
- R) R5 v, j, J- HInitialize variables
/ M0 [* O1 Q* l* a  X(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):6 z: u) k$ E! t
h0 := 0x6a09e667
' k* d  x" g4 \5 L' A6 \h1 := 0xbb67ae852 O* C; m# k6 B& n, N
h2 := 0x3c6ef372
9 k% w! t7 t# c$ W/ r& u) Yh3 := 0xa54ff53a
3 O  y% H# V7 I9 G" kh4 := 0x510e527f5 l0 w7 j; P, a6 w/ m& k  b1 _
h5 := 0x9b05688c. W' {* I+ `% x# l0 ~
h6 := 0x1f83d9ab( \& _8 G, x( @3 v- }
h7 := 0x5be0cd19
0 G; R+ l7 J0 J5 g* D) e) d2 a& `7 O然后还要初始化64个值，分别是最开始的连续64个素数（从2到311）的立方根的二进制表示的小数部分的前32位，可以看到这64个数也成了数组的形式，因为是要在后面每次迭代中拿来进行循环运算的。+ p) q& z" `8 B, Y5 K  C! P
Initialize table of round constants; q. W) Q7 r& v' Q7 S( s: ~* H
(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):+ V9 {, `, ~7 c4 Q6 G
k[0..63] :=% ?/ a  z! V  ]3 w: v7 `
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
" X( y) x2 M0 K( W( D. b2 o. h$ a   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
/ o  E: ]/ {3 _4 w  n# z. q   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
) M& m% T5 g- l9 k4 P1 e( t   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,* k+ j2 P2 m1 \/ ^* ~* x
   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,- S$ r: I1 A5 _4 |
   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,7 t, }- j. _9 [% j* _5 ]
   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
5 {' a7 H# A) Q   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2* B9 z$ T4 U* h4 v
2.2信息预处理# e' s, A$ Z6 O2 E2 N3 h+ k( n. u" ?
预处理分为三步，首先是在原信息后加一个‘1’；然后再添加k个0，直到信息长度 mod 512 = 448，如果原信息是447这种长度，那其实就不用加0了；最后就是再添加原信息的长度到末尾，是64位的大端模式的格式。$ S8 a- m$ y9 ]. z- n3 C$ c8 l1 M
Pre-processing:  P0 [' t$ |5 O4 S  L
append the bit '1' to the message
1 J0 O# e0 G- t: d" t& D. Kappend k bits '0', where k is the minimum number >= 0 such that the resulting message1 a$ [7 r# h3 S! S* j, e
    length (in bits) is congruent to 448(mod 512)( V8 w+ A7 }1 I. n8 _# H8 V
append length of message (before pre-processing), in bits, as 64-bit big-endian integer- Q- g: `6 V/ w# d# a) I  Y) w7 _! i
2.3生成摘要
" v7 G; Y) w) o. W, ]到了最麻烦的一步了，生成摘要。
0 `, O) v4 i9 `首先，经过第二步，现在信息已经是512bit的倍数这种格式了，所以这里首先是把信息分成块，每一块是512bit，然后每一块都是一次迭代，每一次迭代都会更新摘要，最后一次迭代结果就是最终生成的摘要。, _; c( }: N8 R6 y. F# g; i
所以，关键就是每一步迭代过程中发生了什么。* i0 o9 g6 X& ?  E: Z
对于SHA256算法，最终的摘要是256bit的，结合前面的8个32bit的初值，这里就不难理解了，总的摘要是分成8个值进行更新的。块大小是512bit的，将其也以32bit为单位分成16个，然后通过对16个数进行运算，生成另外48个数，总之，得到了64个值，这和前面的64个常量相对应，剩下的就直接看下图吧：
% e; [, _( ~9 j- {4 y7 ~/ a9 h7 G& q8 O! }8 x
每次迭代摘要的更新流程
) o& R) h- D9 [6 L6 D6 f中间各种运算符什么的，就是一些运算而已，没什么好说的， W是从块中得到的64个数的集合，K是之前初始化的64个数的集合，可以看到一次迭代内部有64次循环，每次循环都会更新一次摘要。6 X2 x" y! w. c+ X" Q  |: `( P. M
最后，来看看伪代码把：5 q) p& }+ S( v( z2 p
Process the message in successive 512-bit chunks:
, m. R, }' r& x7 \break message into 512-bit chunks
% K/ y2 {. x. W% ?% P2 k% I1 N; wfor each chunk7 C, m1 X, l5 H; R
    break chunk into sixteen 32-bit big-endian words w[0..15]! r3 |! X7 }  c7 Z4 u3 t
    Extend the sixteen 32-bit words into sixty-four 32-bit words:" Z+ R& A% Z8 D3 U! C
    for i from 16 to 630 s3 v! S* B9 v% u! y
        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3): \! n' K" ?8 }6 L" W; ~
        s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10)
/ @1 m, c* R+ D9 Y+ e4 d2 D* v' l8 {        w := w[i-16] + s0 + w[i-7] + s1$ E8 G7 `8 d- z( U2 y  O8 v, `
    Initialize hash value for this chunk:
6 K- a* z$ y$ b- W! P& V    a := h05 H9 {. X! f% c* a
    b := h1
0 j/ F' m/ ~5 \3 Z    c := h2
9 p; O. n& V; ?+ Y5 h0 J; D    d := h3
8 a! L* a- g, X2 m    e := h4. P$ d$ k: e/ ]' X, ]3 O
    f := h53 }! ~) k  Z* z- d( H
    g := h6
  ?" t2 m2 k/ e2 J) E    h := h7
$ b* f9 z' {) H; q* `    Main loop:) `3 ^" e+ M7 o! E4 T
    for i from 0 to 63# L( y# F1 {2 U: N+ }
        s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22)
% e) r: q+ k: Y7 u% w: P$ t        maj := (a and b) xor (a and c) xor(b and c)
8 A- x( n8 H) `5 _        t2 := s0 + maj
3 N6 [; b( @* O$ {% N3 }2 A' M: i7 n        s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)2 K0 j3 D! `$ E- Y9 ^
        ch := (e and f) xor ((not e) and g)- v+ A/ G7 x: N. a( b
        t1 := h + s1 + ch + k + w
- S& P: X+ S- K3 ^        h := g
9 I5 U: e! G; I* W! T* c        g := f2 o; O  D! b3 H; K8 b
        f := e1 c, y0 r0 b* a2 n. v2 R
        e := d + t1+ c; S" i$ s' F; \! m3 x/ z4 l
        d := c
8 ~& b$ x* `' D8 h; s* R        c := b3 |( V7 r$ J6 T# k" {& l) ?& `" F+ s9 ^
        b := a
5 b+ q4 I2 ]/ D! |* P/ _$ e        a := t1 + t26 ^! t' M" d, M. r2 s) z/ n8 @; u5 F
    Add this chunk's hash to result so far:
' m( m: ~  T' K    h0 := h0 + a
  n" x( L6 @! }8 \9 N    h1 := h1 + b
/ E' y# S5 K2 q1 T& v* a: _6 S1 x: c1 }    h2 := h2 + c
8 i8 R3 M. m, X    h3 := h3 + d
  `3 h4 r8 @& H/ q    h4 := h4 + e* P! c7 Y% e  T. P4 V' k
    h5 := h5 + f: e- Z3 e! v7 {
    h6 := h6 + g0 u$ K- l6 s, [# t
    h7 := h7 + h
- q4 N/ n/ m2 E+ |Produce the final hash value (big-endian):2 L; C% f7 T4 i" d2 Q7 o
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h74 i8 j* Z2 f1 a4 t
一目了然，对吧。
& ^5 V0 @- K& L9 i