1.SHA简介
- @0 M6 j- I- B- M+ ~( P关于SHA的定义直接参考wiki介绍：. v5 G# s4 o0 V2 Z6 D/ L
安全散列算法（英语：Secure Hash Algorithm，缩写为SHA）是一个密码散列函数家族，是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的，长度固定的字符串（又称消息摘要）的算法。且若输入的消息不同，它们对应到不同字符串的机率很高。
- L! u  {% M  J& tSHA可看作是是一种单向函数，几乎不可逆，给一段信息，它会给你生成固定长度的摘要，当然，不同的信息是的确有可能生成相同的摘要的，这被称作碰撞，简单来说，摘要的长度越长，碰撞几率越低。
  |# [6 Z9 j* ^既然有碰撞这种可能性，那碰撞肯定会被拿来用作攻击手段的，SHA-1已经在17年被Google和荷兰的小组攻破了，目前使用的标准是SHA-2，其实在算法上SHA-2和SHA-1区别不大，但是至今SHA-2还没被攻破，所以暂且当它没什么弱点。
& \6 B; G- C- x从SHA的特点来看，用来作文件验证和数字签名是非常合适的。比特币使用的就是SHA-2中的SHA256算法。% w4 G6 O& u* f. x# B4 }( r, v
2.SHA256的算法实现% B8 @& l  w+ C! n4 p
首先，SHA算法在数学原理上是相当复杂的（那些移位与或非对于算法的作用看着就头大），对于不以密码学研究为目的，同时也是初学者的我来说，去分析它的数学细节对我没有什么意义，因此我暂且忽略那一部分直接看它的算法实现。
9 [9 a8 `* c% F1 B" P9 V4 c' D5 U% a实现可以分为三个部分：常量初始化，信息预处理，生成摘要。
% E  s3 @1 Q4 w2 j, k2.1常量初始化
  p( ]) W3 G: Z8 k- X2 V首先是初始化8个值，分别是最开始的连续8个素数（从2到19）的平方根的二进制表示的小数部分的前32位，有点绕，不过就是这样啦，这些后面会作为迭代的初值使用。
7 a; |; d0 S% W! RInitialize variables
* G/ [4 I% m$ N' Y  w(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
. m3 [1 O/ P) J+ z) v4 {h0 := 0x6a09e667
+ Z; Q% M* R+ eh1 := 0xbb67ae85% \8 a$ x' N+ h% s! R
h2 := 0x3c6ef372
% U/ ^1 ^) W+ U: z7 `/ m, hh3 := 0xa54ff53a
$ Q5 X5 `# H$ N" Vh4 := 0x510e527f- `' v9 P1 T6 f. I5 ]7 {$ o7 B0 [
h5 := 0x9b05688c
( j* }* B) B8 @6 p, f. qh6 := 0x1f83d9ab
' V8 G1 B$ G8 p2 c6 _$ [8 ~h7 := 0x5be0cd19! x. d- d2 P0 Z5 t! v
然后还要初始化64个值，分别是最开始的连续64个素数（从2到311）的立方根的二进制表示的小数部分的前32位，可以看到这64个数也成了数组的形式，因为是要在后面每次迭代中拿来进行循环运算的。; F2 W: T0 Y# T2 O( ^
Initialize table of round constants
4 Y9 a' Y# S, X4 W(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
9 B7 Y- {9 K# Y; Tk[0..63] :=$ z) k+ B) `; y) d8 x* X# F; ~
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,2 y% S) q0 P7 n" K/ Y
   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,5 L/ M' z' T+ }; d
   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da," \0 F. V/ I* t" g
   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,7 z' {" r' x0 x
   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+ Z! G/ S5 n3 O# H! {   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,$ P4 _& B" k% b( c! I5 V8 N/ V, ?
   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
- ]7 T2 u6 K+ X   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2$ o! u* `$ {3 ~) U
2.2信息预处理1 K/ ]# p, ?5 W- x( i
预处理分为三步，首先是在原信息后加一个‘1’；然后再添加k个0，直到信息长度 mod 512 = 448，如果原信息是447这种长度，那其实就不用加0了；最后就是再添加原信息的长度到末尾，是64位的大端模式的格式。5 ~/ |- v" A2 j3 Z( O6 }
Pre-processing:
: f+ u5 {& l0 f3 G$ M: zappend the bit '1' to the message
3 S6 q& @) f' cappend k bits '0', where k is the minimum number >= 0 such that the resulting message
1 o0 f3 M6 I, E" Z5 f% q    length (in bits) is congruent to 448(mod 512)* S% f  o) C+ q. \
append length of message (before pre-processing), in bits, as 64-bit big-endian integer
8 f0 O1 Q2 B2 G( h0 {2.3生成摘要$ ^- ~* i; `% D; d/ n* {5 D( j/ H! q% R
到了最麻烦的一步了，生成摘要。* }1 {* U) J' b
首先，经过第二步，现在信息已经是512bit的倍数这种格式了，所以这里首先是把信息分成块，每一块是512bit，然后每一块都是一次迭代，每一次迭代都会更新摘要，最后一次迭代结果就是最终生成的摘要。
7 v/ K2 L6 t% u; D# W" h所以，关键就是每一步迭代过程中发生了什么。, Q4 l' M  s; x( f
对于SHA256算法，最终的摘要是256bit的，结合前面的8个32bit的初值，这里就不难理解了，总的摘要是分成8个值进行更新的。块大小是512bit的，将其也以32bit为单位分成16个，然后通过对16个数进行运算，生成另外48个数，总之，得到了64个值，这和前面的64个常量相对应，剩下的就直接看下图吧：4 q" k& d1 j3 N, _* i4 P) o% J
: V! b& u4 U! u& P
每次迭代摘要的更新流程
5 Q. M$ W+ i1 ?+ \/ c- F- k中间各种运算符什么的，就是一些运算而已，没什么好说的， W是从块中得到的64个数的集合，K是之前初始化的64个数的集合，可以看到一次迭代内部有64次循环，每次循环都会更新一次摘要。6 t7 u' B5 e: T- x3 l
最后，来看看伪代码把：6 D" y* q, t; x0 l' C/ k4 G
Process the message in successive 512-bit chunks:
7 `/ J4 C: m' K, X1 k3 |5 bbreak message into 512-bit chunks
) }! d* u( u3 L6 C: E2 l" {for each chunk
  R4 P  q" V& n( m8 @    break chunk into sixteen 32-bit big-endian words w[0..15]# h3 V. U4 b$ T/ P. O0 v$ K" h
    Extend the sixteen 32-bit words into sixty-four 32-bit words:& v) J; F7 I) u( ^9 [$ e
    for i from 16 to 63
3 i# H; J5 @2 b. T* ^4 N" \        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3)* \8 M9 s1 W5 i1 w# r: s4 S
        s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10)
4 N; a3 |7 M3 _        w := w[i-16] + s0 + w[i-7] + s1* ]" S$ W" o5 i" }9 Z
    Initialize hash value for this chunk:; Y; C' h2 o" F5 `- S
    a := h0
! `$ D4 T0 S9 V    b := h1
: N- j. w& \1 a$ ~- |( |    c := h2; S% Q( `9 y$ v8 r2 y" G
    d := h36 D8 N, I! [! Y# t! R% i
    e := h4
- |; G0 }1 l7 y* r; n  g    f := h5
& c; x- g' M+ k$ ~    g := h6
* G$ b' q; v% l' |9 w" {    h := h7
" e) ], Q+ U+ G, [, v    Main loop:1 p8 J( H  ~8 k6 S8 `
    for i from 0 to 63
9 U4 |8 A* i! }; @' m- {7 X" o+ x8 R" l        s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22)
& o$ [/ S8 v( E& r# z" A, P        maj := (a and b) xor (a and c) xor(b and c)7 G: z0 i' R! a3 J  b9 M  ]2 z
        t2 := s0 + maj/ W0 F& N, v" y% G8 E
        s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)/ C* b% g: H# r0 G* K: S
        ch := (e and f) xor ((not e) and g)+ n! H# \9 l6 |3 `0 @! ^$ G: P
        t1 := h + s1 + ch + k + w
% S2 m$ x: \: Q( f+ g        h := g5 r$ v( I' `) `% y' n4 v' `9 T
        g := f
* r, Q7 P; T" d: i! |' r  Q        f := e
. i8 S) ]9 y$ k        e := d + t1' D0 s( h5 x0 w( d! S
        d := c4 q$ ~: |& q% t: S* L. f  B
        c := b
9 S: w8 G( w: I5 F4 q: \; Y        b := a# o* P5 \8 \. U# I
        a := t1 + t27 f5 w) G# W+ U3 d  {+ e9 \: M
    Add this chunk's hash to result so far:" p" U- L8 u- g, a2 V" m! m
    h0 := h0 + a1 n- C' [/ o) C/ [
    h1 := h1 + b' V6 t6 l# e3 e7 j9 ]$ g$ M- H  X
    h2 := h2 + c0 C+ ^2 e" y7 c$ J$ O. {
    h3 := h3 + d0 O4 F3 H+ R) v. e2 \/ x
    h4 := h4 + e  F, Y, w; ?$ r* K, n% B
    h5 := h5 + f. l6 Z4 b; o) f. i
    h6 := h6 + g4 F' u8 T( j. V% i+ `
    h7 := h7 + h+ Y% S$ F; Z* e  b2 K$ d
Produce the final hash value (big-endian):( }8 M6 S1 d  H, C: V
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
. F! G5 p/ u7 O/ [一目了然，对吧。. c; c8 o% d5 |# `, }- E/ W- k