Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

SHA256实现解析(不涉及数学原理)

李悔之2015
92 0 0
1.SHA简介
7 }1 Y. z' M: U  {1 p关于SHA的定义直接参考wiki介绍:9 j) R- D2 s' O1 j$ P- ^
安全散列算法(英语:Secure Hash Algorithm,缩写为SHA)是一个密码散列函数家族,是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的,长度固定的字符串(又称消息摘要)的算法。且若输入的消息不同,它们对应到不同字符串的机率很高。
; O/ J5 Y8 ?; Y3 L* b1 fSHA可看作是是一种单向函数,几乎不可逆,给一段信息,它会给你生成固定长度的摘要,当然,不同的信息是的确有可能生成相同的摘要的,这被称作碰撞,简单来说,摘要的长度越长,碰撞几率越低。
% o) Q) c/ f# [( k- `既然有碰撞这种可能性,那碰撞肯定会被拿来用作攻击手段的,SHA-1已经在17年被Google和荷兰的小组攻破了,目前使用的标准是SHA-2,其实在算法上SHA-2和SHA-1区别不大,但是至今SHA-2还没被攻破,所以暂且当它没什么弱点。: N5 ]$ _! m, U& ?/ I2 h8 i
从SHA的特点来看,用来作文件验证和数字签名是非常合适的。比特币使用的就是SHA-2中的SHA256算法。
1 V% V: @4 |$ R! i! @2.SHA256的算法实现
, V# W! \* m6 A, j5 @  h4 O6 U首先,SHA算法在数学原理上是相当复杂的(那些移位与或非对于算法的作用看着就头大),对于不以密码学研究为目的,同时也是初学者的我来说,去分析它的数学细节对我没有什么意义,因此我暂且忽略那一部分直接看它的算法实现。
) B0 V. b% n0 v4 w7 D0 y$ k' G( d实现可以分为三个部分:常量初始化,信息预处理,生成摘要。
3 P/ B$ W0 _* v2.1常量初始化
: d3 ?# W  d: O3 S. j6 N首先是初始化8个值,分别是最开始的连续8个素数(从2到19)的平方根的二进制表示的小数部分的前32位,有点绕,不过就是这样啦,这些后面会作为迭代的初值使用。% A  H% n/ K! d
Initialize variables. ]9 s, T+ a* `$ `6 a5 t
(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
# p9 e5 D: |% x8 Dh0 := 0x6a09e667
- `+ e: F& @; j$ w; V" g8 y/ ih1 := 0xbb67ae85
2 g" A* z9 q2 ^" n! w+ u, ]h2 := 0x3c6ef372% s; T' R4 F( B0 h' B# C8 ]+ L
h3 := 0xa54ff53a
2 _: O! z: G, y3 bh4 := 0x510e527f* k6 K  D' H3 U' C; `4 Q- Q1 v
h5 := 0x9b05688c+ e% r$ i/ c1 W: R
h6 := 0x1f83d9ab0 H9 O! A" [( N
h7 := 0x5be0cd19: K3 r) s, c  U* m3 L- d6 s
然后还要初始化64个值,分别是最开始的连续64个素数(从2到311)的立方根的二进制表示的小数部分的前32位,可以看到这64个数也成了数组的形式,因为是要在后面每次迭代中拿来进行循环运算的。
! K) A$ M% [/ M7 C+ `! SInitialize table of round constants: ?/ Z* W; m/ k& T0 h* U6 L  \, j
(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):
; S2 T# b' H$ B6 j, U0 Gk[0..63] :=# o+ ~( Z, I* ?% C' Z& U, l, s& x
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
3 x5 h$ x+ f& \7 U   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
2 Z( _" M4 x- J. t( A: {   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
! N4 ?, L  G  H# D/ D; M9 [   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,( ^0 q8 K- @/ M+ f1 I
   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,3 G( ^# k# _, @6 u, E( @
   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
" Y' f( q7 k( _* W5 [   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
7 S# t4 s+ D& _. x! t   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f26 e: E1 a- z! @$ O
2.2信息预处理- ^. B% o, z( q$ l
预处理分为三步,首先是在原信息后加一个‘1’;然后再添加k个0,直到信息长度 mod 512 = 448,如果原信息是447这种长度,那其实就不用加0了;最后就是再添加原信息的长度到末尾,是64位的大端模式的格式。8 M2 Q+ v9 b8 k
Pre-processing:( b3 d' D# U  b/ s, \/ ^0 K
append the bit '1' to the message
% o+ {" z  U! R, D' B7 j+ mappend k bits '0', where k is the minimum number >= 0 such that the resulting message/ y2 d( ?% L5 L4 U" T5 b
    length (in bits) is congruent to 448(mod 512)4 S0 a' p0 o. d' }3 |8 m
append length of message (before pre-processing), in bits, as 64-bit big-endian integer
, Z) a2 K- M3 s% {% Z2.3生成摘要
$ s- k6 X+ m# i' X8 {0 V: T9 x5 ~# O到了最麻烦的一步了,生成摘要。6 }  K! P$ y! f& P9 X: a9 t; h; S' v
首先,经过第二步,现在信息已经是512bit的倍数这种格式了,所以这里首先是把信息分成块,每一块是512bit,然后每一块都是一次迭代,每一次迭代都会更新摘要,最后一次迭代结果就是最终生成的摘要。1 o; ~# u  H! q3 t5 D
所以,关键就是每一步迭代过程中发生了什么。
$ v- Z3 c5 ?: z$ I/ m# z6 ?  \$ I对于SHA256算法,最终的摘要是256bit的,结合前面的8个32bit的初值,这里就不难理解了,总的摘要是分成8个值进行更新的。块大小是512bit的,将其也以32bit为单位分成16个,然后通过对16个数进行运算,生成另外48个数,总之,得到了64个值,这和前面的64个常量相对应,剩下的就直接看下图吧:
& c* g2 Z2 A# E$ T5 A) L) H
% ~$ V3 c: X$ G7 {' z1 f; W每次迭代摘要的更新流程
. K( g$ V0 C: r! `7 j2 N) D中间各种运算符什么的,就是一些运算而已,没什么好说的, W是从块中得到的64个数的集合,K是之前初始化的64个数的集合,可以看到一次迭代内部有64次循环,每次循环都会更新一次摘要。7 Z. G: ^3 t. d9 Q) R! C3 H
最后,来看看伪代码把:
: v6 @- V6 w( b0 BProcess the message in successive 512-bit chunks:- D1 K/ f' K, _3 o) U
break message into 512-bit chunks
$ U! j; e* S0 i7 \; h8 |- k+ e. G6 Yfor each chunk
2 T# \  Y* R1 q) Z. ?8 ^5 R+ v    break chunk into sixteen 32-bit big-endian words w[0..15]
5 P5 f' u  e6 m! V. L& y    Extend the sixteen 32-bit words into sixty-four 32-bit words:
! Z0 \- f5 P( E6 r    for i from 16 to 63
' O1 y3 J) `6 A) `) S1 L9 f        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3)
9 }. |* d' q4 d" `        s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10)
4 H: h, b( g% N1 E5 i' `+ Y' e7 x        w := w[i-16] + s0 + w[i-7] + s1
: e3 [" ?% o8 n% l% x    Initialize hash value for this chunk:$ ?8 h& U! a4 f/ ]
    a := h0
2 l- u6 G. c3 l* V# Q( A    b := h1
+ a! D( W# D8 q    c := h2
5 ]7 @& f6 F& c! G8 _% f7 i    d := h3
3 R. h' n, @! h2 R    e := h4& A- B6 S+ z9 j7 b! N# u+ @$ f+ l
    f := h56 j# z0 `! r, v2 W! w
    g := h67 l  z6 h9 P0 d$ b# P9 Y3 z& B
    h := h7
2 N6 r: K. c2 s4 A6 V    Main loop:/ \+ j3 a5 [8 j
    for i from 0 to 63
- x0 B7 n- t& f$ k+ k1 K        s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22)- }. r; ~7 L& B* G
        maj := (a and b) xor (a and c) xor(b and c)  j2 \1 N6 \7 J5 h3 u3 U
        t2 := s0 + maj
# |  O6 R* y/ \. o/ h6 N, L        s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)
6 J( e$ q2 O& T0 {        ch := (e and f) xor ((not e) and g)+ I1 Z3 ^, A+ J5 F* Z+ f
        t1 := h + s1 + ch + k + w+ [% U+ m1 t4 X$ Q, I. S& S0 S; T
        h := g2 v* T; Q; g1 |5 _# F
        g := f4 I2 a( v; P' C3 x( O8 v% ]
        f := e/ r6 N% G; Z! r4 ]2 Y/ j0 ]
        e := d + t1
9 T3 u* ^7 i& b, `        d := c
6 q, m5 R4 s8 l        c := b
" b0 b5 }6 f, C# w2 K0 m' _5 }        b := a
! b7 V7 d: ]/ X8 E  z) I        a := t1 + t2
& r. N6 }5 v  \4 w4 `    Add this chunk's hash to result so far:
1 f& p; B9 {0 i8 |" V- S    h0 := h0 + a
& U1 Z0 u( ?2 o8 M# K    h1 := h1 + b6 d1 j. ^; u: H1 `
    h2 := h2 + c
5 T& l3 K. M! `* ]0 ~    h3 := h3 + d
% F+ [/ m8 P0 J5 d    h4 := h4 + e
" `) P! O, v/ H" D# C9 ?    h5 := h5 + f
6 Q3 h: g8 \, N    h6 := h6 + g
  Y% l& B) q0 |, F$ w    h7 := h7 + h
8 S; W: ?+ S) a; {3 @6 KProduce the final hash value (big-endian):
  O# k4 ^5 x8 h2 Xdigest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h70 ?5 l" F+ q" v7 d8 W
一目了然,对吧。
& r% Y2 n! T; D. ^0 `
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

李悔之2015 初中生
  • 粉丝

    1

  • 关注

    0

  • 主题

    13