Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

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

李悔之2015
254 0 0
1.SHA简介# C& g( O% k6 n. K! l4 [
关于SHA的定义直接参考wiki介绍:( N4 q" l8 \# a& d9 S, G% t5 y
安全散列算法(英语:Secure Hash Algorithm,缩写为SHA)是一个密码散列函数家族,是FIPS所认证的安全散列算法。能计算出一个数字消息所对应到的,长度固定的字符串(又称消息摘要)的算法。且若输入的消息不同,它们对应到不同字符串的机率很高。- B" c1 m6 _9 _( O( d' q7 j5 V2 F
SHA可看作是是一种单向函数,几乎不可逆,给一段信息,它会给你生成固定长度的摘要,当然,不同的信息是的确有可能生成相同的摘要的,这被称作碰撞,简单来说,摘要的长度越长,碰撞几率越低。! J6 f0 Y# _) H$ V  V. O
既然有碰撞这种可能性,那碰撞肯定会被拿来用作攻击手段的,SHA-1已经在17年被Google和荷兰的小组攻破了,目前使用的标准是SHA-2,其实在算法上SHA-2和SHA-1区别不大,但是至今SHA-2还没被攻破,所以暂且当它没什么弱点。' b( h0 `1 j1 ^  h
从SHA的特点来看,用来作文件验证和数字签名是非常合适的。比特币使用的就是SHA-2中的SHA256算法。
6 ?1 e2 R6 b& z! L4 ^" M+ T2.SHA256的算法实现8 S" K, V( B/ q; U2 P' K
首先,SHA算法在数学原理上是相当复杂的(那些移位与或非对于算法的作用看着就头大),对于不以密码学研究为目的,同时也是初学者的我来说,去分析它的数学细节对我没有什么意义,因此我暂且忽略那一部分直接看它的算法实现。, D, r( W4 v$ ~0 @. X! E# N
实现可以分为三个部分:常量初始化,信息预处理,生成摘要。
- W  S5 p5 N& |5 w2.1常量初始化3 A$ K1 ?) D6 I1 O$ U  J
首先是初始化8个值,分别是最开始的连续8个素数(从2到19)的平方根的二进制表示的小数部分的前32位,有点绕,不过就是这样啦,这些后面会作为迭代的初值使用。
0 D0 f9 x) m6 S9 Y6 ?3 r) X! u0 L0 X+ IInitialize variables
$ F1 I$ n. c! w& M(first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
5 ]! M. ~$ w2 ~h0 := 0x6a09e667( Y3 R3 ^% O  J' t9 b; z; X/ g
h1 := 0xbb67ae85
" F7 S' t6 g( a& xh2 := 0x3c6ef3722 T- m1 J4 Y" ~; L( z
h3 := 0xa54ff53a" M! V9 ~' M1 ]4 |6 N! ^+ Q
h4 := 0x510e527f
. e/ G# z0 g; A8 Hh5 := 0x9b05688c. @+ p: Q+ E7 e2 k5 }  e9 X
h6 := 0x1f83d9ab
. z8 X" \0 p" X- i/ V& Yh7 := 0x5be0cd19" u# a7 T2 K" u0 ~2 n0 o8 z) F
然后还要初始化64个值,分别是最开始的连续64个素数(从2到311)的立方根的二进制表示的小数部分的前32位,可以看到这64个数也成了数组的形式,因为是要在后面每次迭代中拿来进行循环运算的。
" b- R* l" R; i: o$ D2 D& k3 f, YInitialize table of round constants
9 v! D/ ~$ ]. q2 N% ]% X. H(first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311):1 z( ^6 c3 c" Z5 S
k[0..63] :=3 O! O4 Y& y( S, j8 Q! K! x
   0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
, B. Z/ ]5 q& r# v( S" P+ s   0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,) x7 \% y7 ]' y7 a6 q( w
   0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
* p2 G* \- h# I5 w# a   0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
# X$ Q4 N" p/ @7 h   0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
! P  w5 |6 S1 l9 M   0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,, f0 g/ U8 o8 _0 m  T$ u
   0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,& o# ~* a$ p- R- v
   0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
* ?7 f( C9 D" f2.2信息预处理
9 ?) v" `2 @$ P! A& t' ^$ u预处理分为三步,首先是在原信息后加一个‘1’;然后再添加k个0,直到信息长度 mod 512 = 448,如果原信息是447这种长度,那其实就不用加0了;最后就是再添加原信息的长度到末尾,是64位的大端模式的格式。
8 x) m+ j. `2 }: e; O( N! UPre-processing:( E4 D& q/ S$ C& A0 A5 q
append the bit '1' to the message
; W7 {. H4 X6 q; ~. S2 c' N- P* `append k bits '0', where k is the minimum number >= 0 such that the resulting message
2 }  l7 d2 V' o+ D& X5 j; D    length (in bits) is congruent to 448(mod 512)
$ t' t! [5 U5 k! U; zappend length of message (before pre-processing), in bits, as 64-bit big-endian integer* T% M0 b- F) p
2.3生成摘要9 s4 b/ |6 T5 b
到了最麻烦的一步了,生成摘要。/ X/ H7 N8 I' a8 r* d* i# h
首先,经过第二步,现在信息已经是512bit的倍数这种格式了,所以这里首先是把信息分成块,每一块是512bit,然后每一块都是一次迭代,每一次迭代都会更新摘要,最后一次迭代结果就是最终生成的摘要。
3 |+ u# [6 Q, G) N所以,关键就是每一步迭代过程中发生了什么。
3 c5 A+ C% _! @0 T对于SHA256算法,最终的摘要是256bit的,结合前面的8个32bit的初值,这里就不难理解了,总的摘要是分成8个值进行更新的。块大小是512bit的,将其也以32bit为单位分成16个,然后通过对16个数进行运算,生成另外48个数,总之,得到了64个值,这和前面的64个常量相对应,剩下的就直接看下图吧:- F' j- O3 ], K* T, P/ e  Q1 d; S4 k

) F! V" @6 y" X9 K. z% J每次迭代摘要的更新流程
: ?- i5 H1 s' l6 r" {9 q6 I中间各种运算符什么的,就是一些运算而已,没什么好说的, W是从块中得到的64个数的集合,K是之前初始化的64个数的集合,可以看到一次迭代内部有64次循环,每次循环都会更新一次摘要。
6 \, H: n) a; S+ B最后,来看看伪代码把:/ L2 ]% ]3 B8 \
Process the message in successive 512-bit chunks:
# T! Z# l" ]9 C- Hbreak message into 512-bit chunks
0 t3 \9 g& S* J% J1 i$ _7 f. `# bfor each chunk
6 r+ A3 S: `& \* |/ Q% q    break chunk into sixteen 32-bit big-endian words w[0..15]
$ v8 z  M5 c8 Y2 K; O  u/ ^    Extend the sixteen 32-bit words into sixty-four 32-bit words:6 D& L4 E9 Q" X! c/ x) a0 y
    for i from 16 to 63
, }  D0 m/ O! ?/ w0 Z        s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor(w[i-15] rightshift 3)8 b; d& L1 A2 Z: r' s: J
        s1 := (w[i-2] rightrotate 17) xor (w[i-2] rightrotate 19) xor(w[i-2] rightshift 10); J0 n8 W& J% `  T8 N5 i( [  N
        w := w[i-16] + s0 + w[i-7] + s15 W% J% U0 C0 b( G2 f
    Initialize hash value for this chunk:
. Q/ l( y( V& A6 K' z2 O    a := h0# m9 T6 d, }+ N+ \
    b := h1: X5 g' |% F7 {& \) ]
    c := h2
- s8 ]0 d' N6 R+ T    d := h3
6 y* W: q# A, u    e := h4# B1 n) q! C: `, b& h
    f := h5
. p4 v) y' ^5 y& ?! s! ~    g := h62 ?  E4 A. I- t% R) x
    h := h7
# X/ ]0 X1 g: B8 {- f    Main loop:
. f# b6 b# M, P9 `0 J2 f& B    for i from 0 to 63
3 W9 J5 @- a' V) A/ D" W        s0 := (a rightrotate 2) xor (a rightrotate 13) xor(a rightrotate 22)5 i. e; x* e7 o6 p) {  F3 e# l
        maj := (a and b) xor (a and c) xor(b and c)% Q. w% V3 R9 ^7 H5 K
        t2 := s0 + maj
, ^3 [9 K( ?( g* R/ v3 d        s1 := (e rightrotate 6) xor (e rightrotate 11) xor(e rightrotate 25)
1 m' F* R2 z" A' f2 C        ch := (e and f) xor ((not e) and g)0 E9 H" B$ a! l# F
        t1 := h + s1 + ch + k + w
, B$ G- g; h" ]0 u7 m' H) `; b4 C        h := g  _) s8 d! p3 ?2 l4 \4 j3 f
        g := f% O* ^) W3 t% I3 W. W
        f := e  ~: L1 g) }  q% s
        e := d + t1
3 H7 O+ R0 v# a, M2 d- f9 w        d := c
4 c: m, O4 s, E. c4 E# S( C        c := b
  }% S# c6 y7 ?0 u- ]: f( x+ A. F5 [        b := a- p1 e5 T! {! |. w1 s
        a := t1 + t2
+ I- b) p4 a2 |. [9 F  Y+ w6 T    Add this chunk's hash to result so far:; L2 C, M3 U, v; b7 m* |, f! z3 Z
    h0 := h0 + a
; Y( I% ^. g3 c7 Z( _. n    h1 := h1 + b  ~( C' I$ J0 L4 J* w( m3 a1 I" V
    h2 := h2 + c
2 B# S7 M; {4 I3 b  X, a    h3 := h3 + d
) V5 T5 Q2 s, @: p8 Y! g    h4 := h4 + e! J* r/ i$ E0 k0 l2 k3 D
    h5 := h5 + f
; C0 L/ F# ?% h8 Y    h6 := h6 + g
3 s+ G& z5 [1 ~; `' L2 h$ W    h7 := h7 + h
2 e, b$ h" m; G2 pProduce the final hash value (big-endian):) k* z/ h2 ?! v& L  o  J
digest = hash = h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
6 Q. q$ `  D( O6 i1 b) I一目了然,对吧。, t$ z5 p6 d7 ^% [2 N8 P
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

李悔之2015 初中生
  • 粉丝

    1

  • 关注

    0

  • 主题

    13