Created
January 22, 2017 22:07
-
-
Save mkarneim/40a078ff906af2d8659230550feb1dd8 to your computer and use it in GitHub Desktop.
MD5 sum in pure Lua
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
local md5 = { | |
_VERSION = "md5.lua 1.1.0", | |
_DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)", | |
_URL = "https://github.com/kikito/md5.lua", | |
_LICENSE = [[ | |
MIT LICENSE | |
Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software | |
Permission is hereby granted, free of charge, to any person obtaining a | |
copy of this software and associated documentation files (the | |
"Software"), to deal in the Software without restriction, including | |
without limitation the rights to use, copy, modify, merge, publish, | |
distribute, sublicense, and/or sell copies of the Software, and to | |
permit persons to whom the Software is furnished to do so, subject to | |
the following conditions: | |
The above copyright notice and this permission notice shall be included | |
in all copies or substantial portions of the Software. | |
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | |
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | |
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | |
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |
]] | |
} | |
-- bit lib implementions | |
local char, byte, format, rep, sub = | |
string.char, string.byte, string.format, string.rep, string.sub | |
local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift | |
local ok, bit = pcall(require, 'bit') | |
if ok then | |
bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift | |
else | |
ok, bit = pcall(require, 'bit32') | |
if ok then | |
bit_not = bit.bnot | |
local tobit = function(n) | |
return n <= 0x7fffffff and n or -(bit_not(n) + 1) | |
end | |
local normalize = function(f) | |
return function(a,b) return tobit(f(tobit(a), tobit(b))) end | |
end | |
bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor) | |
bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift) | |
else | |
local function tbl2number(tbl) | |
local result = 0 | |
local power = 1 | |
for i = 1, #tbl do | |
result = result + tbl[i] * power | |
power = power * 2 | |
end | |
return result | |
end | |
local function expand(t1, t2) | |
local big, small = t1, t2 | |
if(#big < #small) then | |
big, small = small, big | |
end | |
-- expand small | |
for i = #small + 1, #big do | |
small[i] = 0 | |
end | |
end | |
local to_bits -- needs to be declared before bit_not | |
bit_not = function(n) | |
local tbl = to_bits(n) | |
local size = math.max(#tbl, 32) | |
for i = 1, size do | |
if(tbl[i] == 1) then | |
tbl[i] = 0 | |
else | |
tbl[i] = 1 | |
end | |
end | |
return tbl2number(tbl) | |
end | |
-- defined as local above | |
to_bits = function (n) | |
if(n < 0) then | |
-- negative | |
return to_bits(bit_not(math.abs(n)) + 1) | |
end | |
-- to bits table | |
local tbl = {} | |
local cnt = 1 | |
local last | |
while n > 0 do | |
last = n % 2 | |
tbl[cnt] = last | |
n = (n-last)/2 | |
cnt = cnt + 1 | |
end | |
return tbl | |
end | |
bit_or = function(m, n) | |
local tbl_m = to_bits(m) | |
local tbl_n = to_bits(n) | |
expand(tbl_m, tbl_n) | |
local tbl = {} | |
for i = 1, #tbl_m do | |
if(tbl_m[i]== 0 and tbl_n[i] == 0) then | |
tbl[i] = 0 | |
else | |
tbl[i] = 1 | |
end | |
end | |
return tbl2number(tbl) | |
end | |
bit_and = function(m, n) | |
local tbl_m = to_bits(m) | |
local tbl_n = to_bits(n) | |
expand(tbl_m, tbl_n) | |
local tbl = {} | |
for i = 1, #tbl_m do | |
if(tbl_m[i]== 0 or tbl_n[i] == 0) then | |
tbl[i] = 0 | |
else | |
tbl[i] = 1 | |
end | |
end | |
return tbl2number(tbl) | |
end | |
bit_xor = function(m, n) | |
local tbl_m = to_bits(m) | |
local tbl_n = to_bits(n) | |
expand(tbl_m, tbl_n) | |
local tbl = {} | |
for i = 1, #tbl_m do | |
if(tbl_m[i] ~= tbl_n[i]) then | |
tbl[i] = 1 | |
else | |
tbl[i] = 0 | |
end | |
end | |
return tbl2number(tbl) | |
end | |
bit_rshift = function(n, bits) | |
local high_bit = 0 | |
if(n < 0) then | |
-- negative | |
n = bit_not(math.abs(n)) + 1 | |
high_bit = 0x80000000 | |
end | |
local floor = math.floor | |
for i=1, bits do | |
n = n/2 | |
n = bit_or(floor(n), high_bit) | |
end | |
return floor(n) | |
end | |
bit_lshift = function(n, bits) | |
if(n < 0) then | |
-- negative | |
n = bit_not(math.abs(n)) + 1 | |
end | |
for i=1, bits do | |
n = n*2 | |
end | |
return bit_and(n, 0xFFFFFFFF) | |
end | |
end | |
end | |
-- convert little-endian 32-bit int to a 4-char string | |
local function lei2str(i) | |
local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end | |
return f(0)..f(8)..f(16)..f(24) | |
end | |
-- convert raw string to big-endian int | |
local function str2bei(s) | |
local v=0 | |
for i=1, #s do | |
v = v * 256 + byte(s, i) | |
end | |
return v | |
end | |
-- convert raw string to little-endian int | |
local function str2lei(s) | |
local v=0 | |
for i = #s,1,-1 do | |
v = v*256 + byte(s, i) | |
end | |
return v | |
end | |
-- cut up a string in little-endian ints of given size | |
local function cut_le_str(s,...) | |
local o, r = 1, {} | |
local args = {...} | |
for i=1, #args do | |
table.insert(r, str2lei(sub(s, o, o + args[i] - 1))) | |
o = o + args[i] | |
end | |
return r | |
end | |
local swap = function (w) return str2bei(lei2str(w)) end | |
-- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh) | |
-- 10/02/2001 jcw@equi4.com | |
local CONSTS = { | |
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, | |
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, | |
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, | |
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, | |
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, | |
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, | |
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, | |
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, | |
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, | |
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, | |
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, | |
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, | |
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, | |
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, | |
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, | |
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, | |
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476 | |
} | |
local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end | |
local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end | |
local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end | |
local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end | |
local z=function (ff,a,b,c,d,x,s,ac) | |
a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF) | |
-- be *very* careful that left shift does not cause rounding! | |
return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b | |
end | |
local function transform(A,B,C,D,X) | |
local a,b,c,d=A,B,C,D | |
local t=CONSTS | |
a=z(f,a,b,c,d,X[ 0], 7,t[ 1]) | |
d=z(f,d,a,b,c,X[ 1],12,t[ 2]) | |
c=z(f,c,d,a,b,X[ 2],17,t[ 3]) | |
b=z(f,b,c,d,a,X[ 3],22,t[ 4]) | |
a=z(f,a,b,c,d,X[ 4], 7,t[ 5]) | |
d=z(f,d,a,b,c,X[ 5],12,t[ 6]) | |
c=z(f,c,d,a,b,X[ 6],17,t[ 7]) | |
b=z(f,b,c,d,a,X[ 7],22,t[ 8]) | |
a=z(f,a,b,c,d,X[ 8], 7,t[ 9]) | |
d=z(f,d,a,b,c,X[ 9],12,t[10]) | |
c=z(f,c,d,a,b,X[10],17,t[11]) | |
b=z(f,b,c,d,a,X[11],22,t[12]) | |
a=z(f,a,b,c,d,X[12], 7,t[13]) | |
d=z(f,d,a,b,c,X[13],12,t[14]) | |
c=z(f,c,d,a,b,X[14],17,t[15]) | |
b=z(f,b,c,d,a,X[15],22,t[16]) | |
a=z(g,a,b,c,d,X[ 1], 5,t[17]) | |
d=z(g,d,a,b,c,X[ 6], 9,t[18]) | |
c=z(g,c,d,a,b,X[11],14,t[19]) | |
b=z(g,b,c,d,a,X[ 0],20,t[20]) | |
a=z(g,a,b,c,d,X[ 5], 5,t[21]) | |
d=z(g,d,a,b,c,X[10], 9,t[22]) | |
c=z(g,c,d,a,b,X[15],14,t[23]) | |
b=z(g,b,c,d,a,X[ 4],20,t[24]) | |
a=z(g,a,b,c,d,X[ 9], 5,t[25]) | |
d=z(g,d,a,b,c,X[14], 9,t[26]) | |
c=z(g,c,d,a,b,X[ 3],14,t[27]) | |
b=z(g,b,c,d,a,X[ 8],20,t[28]) | |
a=z(g,a,b,c,d,X[13], 5,t[29]) | |
d=z(g,d,a,b,c,X[ 2], 9,t[30]) | |
c=z(g,c,d,a,b,X[ 7],14,t[31]) | |
b=z(g,b,c,d,a,X[12],20,t[32]) | |
a=z(h,a,b,c,d,X[ 5], 4,t[33]) | |
d=z(h,d,a,b,c,X[ 8],11,t[34]) | |
c=z(h,c,d,a,b,X[11],16,t[35]) | |
b=z(h,b,c,d,a,X[14],23,t[36]) | |
a=z(h,a,b,c,d,X[ 1], 4,t[37]) | |
d=z(h,d,a,b,c,X[ 4],11,t[38]) | |
c=z(h,c,d,a,b,X[ 7],16,t[39]) | |
b=z(h,b,c,d,a,X[10],23,t[40]) | |
a=z(h,a,b,c,d,X[13], 4,t[41]) | |
d=z(h,d,a,b,c,X[ 0],11,t[42]) | |
c=z(h,c,d,a,b,X[ 3],16,t[43]) | |
b=z(h,b,c,d,a,X[ 6],23,t[44]) | |
a=z(h,a,b,c,d,X[ 9], 4,t[45]) | |
d=z(h,d,a,b,c,X[12],11,t[46]) | |
c=z(h,c,d,a,b,X[15],16,t[47]) | |
b=z(h,b,c,d,a,X[ 2],23,t[48]) | |
a=z(i,a,b,c,d,X[ 0], 6,t[49]) | |
d=z(i,d,a,b,c,X[ 7],10,t[50]) | |
c=z(i,c,d,a,b,X[14],15,t[51]) | |
b=z(i,b,c,d,a,X[ 5],21,t[52]) | |
a=z(i,a,b,c,d,X[12], 6,t[53]) | |
d=z(i,d,a,b,c,X[ 3],10,t[54]) | |
c=z(i,c,d,a,b,X[10],15,t[55]) | |
b=z(i,b,c,d,a,X[ 1],21,t[56]) | |
a=z(i,a,b,c,d,X[ 8], 6,t[57]) | |
d=z(i,d,a,b,c,X[15],10,t[58]) | |
c=z(i,c,d,a,b,X[ 6],15,t[59]) | |
b=z(i,b,c,d,a,X[13],21,t[60]) | |
a=z(i,a,b,c,d,X[ 4], 6,t[61]) | |
d=z(i,d,a,b,c,X[11],10,t[62]) | |
c=z(i,c,d,a,b,X[ 2],15,t[63]) | |
b=z(i,b,c,d,a,X[ 9],21,t[64]) | |
return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF), | |
bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF) | |
end | |
---------------------------------------------------------------- | |
local function md5_update(self, s) | |
self.pos = self.pos + #s | |
s = self.buf .. s | |
for ii = 1, #s - 63, 64 do | |
local X = cut_le_str(sub(s,ii,ii+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4) | |
assert(#X == 16) | |
X[0] = table.remove(X,1) -- zero based! | |
self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X) | |
end | |
self.buf = sub(s, math.floor(#s/64)*64 + 1, #s) | |
return self | |
end | |
local function md5_finish(self) | |
local msgLen = self.pos | |
local padLen = 56 - msgLen % 64 | |
if msgLen % 64 > 56 then padLen = padLen + 64 end | |
if padLen == 0 then padLen = 64 end | |
local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000)) | |
md5_update(self, s) | |
assert(self.pos % 64 == 0) | |
return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d) | |
end | |
---------------------------------------------------------------- | |
function md5.new() | |
return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68], | |
pos = 0, | |
buf = '', | |
update = md5_update, | |
finish = md5_finish } | |
end | |
function md5.tohex(s) | |
return format("%08x%08x%08x%08x", str2bei(sub(s, 1, 4)), str2bei(sub(s, 5, 8)), str2bei(sub(s, 9, 12)), str2bei(sub(s, 13, 16))) | |
end | |
function md5.sum(s) | |
return md5.new():update(s):finish() | |
end | |
function md5.sumhexa(s) | |
return md5.tohex(md5.sum(s)) | |
end | |
return md5 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment