SHOW:
|
|
- or go back to the newest paste.
1 | -- | |
2 | -- Adaptation of the Secure Hashing Algorithm (SHA-244/256) | |
3 | -- Found Here: http://lua-users.org/wiki/SecureHashAlgorithm | |
4 | -- | |
5 | -- GRAVITYSCORE's adaptation | |
6 | -- Found Here: http://pastebin.com/gsFrNjbt | |
7 | -- Using an adapted version of the bit library | |
8 | -- Found Here: https://bitbucket.org/Boolsheet/bslf/src/1ee664885805/bit.lua | |
9 | -- | |
10 | ||
11 | local MOD = 2^32 | |
12 | local MODM = MOD-1 | |
13 | ||
14 | local function memoize(f) | |
15 | local mt = {} | |
16 | local t = setmetatable({}, mt) | |
17 | function mt:__index(k) | |
18 | local v = f(k) | |
19 | t[k] = v | |
20 | return v | |
21 | end | |
22 | return t | |
23 | end | |
24 | ||
25 | local function make_bitop_uncached(t, m) | |
26 | local function bitop(a, b) | |
27 | local res,p = 0,1 | |
28 | while a ~= 0 and b ~= 0 do | |
29 | local am, bm = a % m, b % m | |
30 | res = res + t[am][bm] * p | |
31 | a = (a - am) / m | |
32 | b = (b - bm) / m | |
33 | p = p*m | |
34 | end | |
35 | res = res + (a + b) * p | |
36 | return res | |
37 | end | |
38 | return bitop | |
39 | end | |
40 | ||
41 | local function make_bitop(t) | |
42 | local op1 = make_bitop_uncached(t,2^1) | |
43 | local op2 = memoize(function(a) return memoize(function(b) return op1(a, b) end) end) | |
44 | return make_bitop_uncached(op2, 2 ^ (t.n or 1)) | |
45 | end | |
46 | ||
47 | local bxor1 = make_bitop({[0] = {[0] = 0,[1] = 1}, [1] = {[0] = 1, [1] = 0}, n = 4}) | |
48 | ||
49 | local function bxor(a, b, c, ...) | |
50 | local z = nil | |
51 | if b then | |
52 | a = a % MOD | |
53 | b = b % MOD | |
54 | z = bxor1(a, b) | |
55 | if c then z = bxor(z, c, ...) end | |
56 | return z | |
57 | elseif a then return a % MOD | |
58 | else return 0 end | |
59 | end | |
60 | ||
61 | local function band(a, b, c, ...) | |
62 | local z | |
63 | if b then | |
64 | a = a % MOD | |
65 | b = b % MOD | |
66 | z = ((a + b) - bxor1(a,b)) / 2 | |
67 | if c then z = bit32_band(z, c, ...) end | |
68 | return z | |
69 | elseif a then return a % MOD | |
70 | else return MODM end | |
71 | end | |
72 | ||
73 | local function bnot(x) return (-1 - x) % MOD end | |
74 | ||
75 | local function rshift1(a, disp) | |
76 | if disp < 0 then return lshift(a,-disp) end | |
77 | return math.floor(a % 2 ^ 32 / 2 ^ disp) | |
78 | end | |
79 | ||
80 | local function rshift(x, disp) | |
81 | if disp > 31 or disp < -31 then return 0 end | |
82 | return rshift1(x % MOD, disp) | |
83 | end | |
84 | ||
85 | local function lshift(a, disp) | |
86 | if disp < 0 then return rshift(a,-disp) end | |
87 | return (a * 2 ^ disp) % 2 ^ 32 | |
88 | end | |
89 | ||
90 | local function rrotate(x, disp) | |
91 | x = x % MOD | |
92 | disp = disp % 32 | |
93 | local low = band(x, 2 ^ disp - 1) | |
94 | return rshift(x, disp) + lshift(low, 32 - disp) | |
95 | end | |
96 | ||
97 | local k = { | |
98 | 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, | |
99 | 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, | |
100 | 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, | |
101 | 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, | |
102 | 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, | |
103 | 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, | |
104 | 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, | |
105 | 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, | |
106 | 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, | |
107 | 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, | |
108 | 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, | |
109 | 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, | |
110 | 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, | |
111 | 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, | |
112 | 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, | |
113 | 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, | |
114 | } | |
115 | ||
116 | local function str2hexa(s) | |
117 | return (string.gsub(s, ".", function(c) return string.format("%02x", string.byte(c)) end)) | |
118 | end | |
119 | ||
120 | local function num2s(l, n) | |
121 | local s = "" | |
122 | for i = 1, n do | |
123 | local rem = l % 256 | |
124 | s = string.char(rem) .. s | |
125 | l = (l - rem) / 256 | |
126 | end | |
127 | return s | |
128 | end | |
129 | ||
130 | local function s232num(s, i) | |
131 | local n = 0 | |
132 | for i = i, i + 3 do n = n*256 + string.byte(s, i) end | |
133 | return n | |
134 | end | |
135 | ||
136 | local function preproc(msg, len) | |
137 | local extra = 64 - ((len + 9) % 64) | |
138 | len = num2s(8 * len, 8) | |
139 | msg = msg .. "\128" .. string.rep("\0", extra) .. len | |
140 | assert(#msg % 64 == 0) | |
141 | return msg | |
142 | end | |
143 | ||
144 | local function initH256(H) | |
145 | H[1] = 0x6a09e667 | |
146 | H[2] = 0xbb67ae85 | |
147 | H[3] = 0x3c6ef372 | |
148 | H[4] = 0xa54ff53a | |
149 | H[5] = 0x510e527f | |
150 | H[6] = 0x9b05688c | |
151 | H[7] = 0x1f83d9ab | |
152 | H[8] = 0x5be0cd19 | |
153 | return H | |
154 | end | |
155 | ||
156 | local function digestblock(msg, i, H) | |
157 | local w = {} | |
158 | for j = 1, 16 do w[j] = s232num(msg, i + (j - 1)*4) end | |
159 | for j = 17, 64 do | |
160 | local v = w[j - 15] | |
161 | local s0 = bxor(rrotate(v, 7), rrotate(v, 18), rshift(v, 3)) | |
162 | v = w[j - 2] | |
163 | w[j] = w[j - 16] + s0 + w[j - 7] + bxor(rrotate(v, 17), rrotate(v, 19), rshift(v, 10)) | |
164 | end | |
165 | ||
166 | local a, b, c, d, e, f, g, h = H[1], H[2], H[3], H[4], H[5], H[6], H[7], H[8] | |
167 | for i = 1, 64 do | |
168 | local s0 = bxor(rrotate(a, 2), rrotate(a, 13), rrotate(a, 22)) | |
169 | local maj = bxor(band(a, b), band(a, c), band(b, c)) | |
170 | local t2 = s0 + maj | |
171 | local s1 = bxor(rrotate(e, 6), rrotate(e, 11), rrotate(e, 25)) | |
172 | local ch = bxor (band(e, f), band(bnot(e), g)) | |
173 | local t1 = h + s1 + ch + k[i] + w[i] | |
174 | h, g, f, e, d, c, b, a = g, f, e, d + t1, c, b, a, t1 + t2 | |
175 | end | |
176 | ||
177 | H[1] = band(H[1] + a) | |
178 | H[2] = band(H[2] + b) | |
179 | H[3] = band(H[3] + c) | |
180 | H[4] = band(H[4] + d) | |
181 | H[5] = band(H[5] + e) | |
182 | H[6] = band(H[6] + f) | |
183 | H[7] = band(H[7] + g) | |
184 | H[8] = band(H[8] + h) | |
185 | end | |
186 | ||
187 | local function sha256(msg) | |
188 | msg = preproc(msg, #msg) | |
189 | local H = initH256({}) | |
190 | for i = 1, #msg, 64 do digestblock(msg, i, H) end | |
191 | return str2hexa(num2s(H[1], 4) .. num2s(H[2], 4) .. num2s(H[3], 4) .. num2s(H[4], 4) .. | |
192 | num2s(H[5], 4) .. num2s(H[6], 4) .. num2s(H[7], 4) .. num2s(H[8], 4)) | |
193 | end |