WikiGOD at 06:03, 2 May 2021

2021-05-02T06:03:48Z

← Older revision		Revision as of 06:03, 2 May 2021
Line 1:		Line 1:
	-- Imports		-- Imports

	local luts = mw.loadData('~~Dev~~:Hash/LUTs')		local luts = mw.loadData('Module:Hash/LUTs')

	-- Utils: bit manipulation		-- Utils: bit manipulation

WikiGOD: 1 revision imported

2021-04-30T02:23:56Z

1 revision imported

← Older revision		Revision as of 02:23, 30 April 2021
(No difference)

Mediawiki>Puxlit: 😂😂😂🤦🏻‍♂️🤦🏻‍♂️🤦🏻‍♂️

2020-08-20T11:55:37Z

😂😂😂🤦🏻‍♂️🤦🏻‍♂️🤦🏻‍♂️

New page

-- Imports

local luts = mw.loadData('Dev:Hash/LUTs')

-- Utils: bit manipulation

local function u32_add(a, b)
return (a + b) % 0x100000000
end

local function u32_and(a, b)
local xx, z = 1, 0
while (a > 0) and (b > 0) do
if ((a % 2) + (b % 2)) == 2 then z = z + xx end
a, b, xx = math.floor(a / 2), math.floor(b / 2), xx * 2
end
return z
end

local function u32_not(a)
return 0xffffffff - a
end

local function u32_or(a, b)
local xx, z = 1, 0
while (a > 0) or (b > 0) do
if ((a % 2) + (b % 2)) > 0 then z = z + xx end
a, b, xx = math.floor(a / 2), math.floor(b / 2), xx * 2
end
return z
end

local function u32_rotl(a, x)
-- We could do a `x = x % 32` or `assert(x % 32 == 0)`, but nah...
local xx = math.floor(2 ^ (32 - x))
return math.floor(a / xx) + ((a % xx) * math.floor(2 ^ x))
end

local function u32_xor(a, b)
local xx, z = 1, 0
while (a ~= b) do
if (a % 2) ~= (b % 2) then z = z + xx end
a, b, xx = math.floor(a / 2), math.floor(b / 2), xx * 2
end
return z
end

-- Utils: structs

local function pack_le_u32(u32)
local b0 = u32 % 0x100; u32 = math.floor(u32 / 0x100)
local b1 = u32 % 0x100; u32 = math.floor(u32 / 0x100)
local b2 = u32 % 0x100; u32 = math.floor(u32 / 0x100)
local b3 = u32 % 0x100
return string.char(b0, b1, b2, b3)
end

local function pack_le_u64(u64)
local b0 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b1 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b2 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b3 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b4 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b5 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b6 = u64 % 0x100; u64 = math.floor(u64 / 0x100)
local b7 = u64 % 0x100
return string.char(b0, b1, b2, b3, b4, b5, b6, b7)
end

local function unpack_le_u32(bytes, offset)
return (string.byte(bytes, offset ) ) +
(string.byte(bytes, offset + 1) * 0x100) +
(string.byte(bytes, offset + 2) * 0x10000) +
(string.byte(bytes, offset + 3) * 0x1000000)
end

-- Utils: representation

local function bytes_to_hex(bytes)
local repr = ''
for i = 1, #bytes do
repr = repr .. string.format('%02x', string.byte(bytes, i))
end
return repr
end

-- Utils: MW helpers

local function make_message(frame)
local i, message = 0, ''
for k, v in ipairs(frame.args) do
if i > 0 then message = message .. '\0' end
i = i + 1
message = message .. v
end
-- Per Scribunto docs, we can't count the number of anonymous/numbered params with `#frame.args`
assert(i > 0, 'Function must be invoked with at least one anonymous or numbered parameter')
return message
end

-- Utils: hash functions

local function md5_f(x, y, z)
return u32_or(u32_and(x, y), u32_and(u32_not(x), z))
end

local function md5_g(x, y, z)
return u32_or(u32_and(x, z), u32_and(y, u32_not(z)))
end

local function md5_h(x, y, z)
return u32_xor(u32_xor(x, y), z)
end

local function md5_i(x, y, z)
return u32_xor(y, u32_or(x, u32_not(z)))
end

local function md5_op(a, b, c, d, aux, x_k, s, t_i)
return u32_add(b, u32_rotl(u32_add(u32_add(a, aux(b, c, d)), u32_add(x_k, t_i)), s))
end

local function md5_init()
return {
is_finalized = false,
buffer = '',
message_length = 0,
-- Initialize MD buffer (per section 3.3 of RFC 1321)
a = 0x67452301,
b = 0xefcdab89,
c = 0x98badcfe,
d = 0x10325476
}
end

local function md5_update(context, message)
assert(not context.is_finalized, 'MD5 context has already been finalized')

local buffer = context.buffer .. message
local partial_block_length = #buffer % 64
context.buffer = (partial_block_length > 0) and string.sub(buffer, -partial_block_length) or ''
context.message_length = context.message_length + #message

-- Process each block (per section 3.4 of RFC 1321)
for i = 0, math.floor(#buffer / 64) - 1 do
local x = {}; for j = 0, 15 do x[j + 1] = unpack_le_u32(buffer, (i * 64) + (j * 4) + 1) end

local a, b, c, d = context.a, context.b, context.c, context.d

-- Round one
a = md5_op(a, b, c, d, md5_f, x[ 1], 7, luts.md5_t[ 1])
d = md5_op(d, a, b, c, md5_f, x[ 2], 12, luts.md5_t[ 2])
c = md5_op(c, d, a, b, md5_f, x[ 3], 17, luts.md5_t[ 3])
b = md5_op(b, c, d, a, md5_f, x[ 4], 22, luts.md5_t[ 4])
a = md5_op(a, b, c, d, md5_f, x[ 5], 7, luts.md5_t[ 5])
d = md5_op(d, a, b, c, md5_f, x[ 6], 12, luts.md5_t[ 6])
c = md5_op(c, d, a, b, md5_f, x[ 7], 17, luts.md5_t[ 7])
b = md5_op(b, c, d, a, md5_f, x[ 8], 22, luts.md5_t[ 8])
a = md5_op(a, b, c, d, md5_f, x[ 9], 7, luts.md5_t[ 9])
d = md5_op(d, a, b, c, md5_f, x[10], 12, luts.md5_t[10])
c = md5_op(c, d, a, b, md5_f, x[11], 17, luts.md5_t[11])
b = md5_op(b, c, d, a, md5_f, x[12], 22, luts.md5_t[12])
a = md5_op(a, b, c, d, md5_f, x[13], 7, luts.md5_t[13])
d = md5_op(d, a, b, c, md5_f, x[14], 12, luts.md5_t[14])
c = md5_op(c, d, a, b, md5_f, x[15], 17, luts.md5_t[15])
b = md5_op(b, c, d, a, md5_f, x[16], 22, luts.md5_t[16])

-- Round two
a = md5_op(a, b, c, d, md5_g, x[ 2], 5, luts.md5_t[17])
d = md5_op(d, a, b, c, md5_g, x[ 7], 9, luts.md5_t[18])
c = md5_op(c, d, a, b, md5_g, x[12], 14, luts.md5_t[19])
b = md5_op(b, c, d, a, md5_g, x[ 1], 20, luts.md5_t[20])
a = md5_op(a, b, c, d, md5_g, x[ 6], 5, luts.md5_t[21])
d = md5_op(d, a, b, c, md5_g, x[11], 9, luts.md5_t[22])
c = md5_op(c, d, a, b, md5_g, x[16], 14, luts.md5_t[23])
b = md5_op(b, c, d, a, md5_g, x[ 5], 20, luts.md5_t[24])
a = md5_op(a, b, c, d, md5_g, x[10], 5, luts.md5_t[25])
d = md5_op(d, a, b, c, md5_g, x[15], 9, luts.md5_t[26])
c = md5_op(c, d, a, b, md5_g, x[ 4], 14, luts.md5_t[27])
b = md5_op(b, c, d, a, md5_g, x[ 9], 20, luts.md5_t[28])
a = md5_op(a, b, c, d, md5_g, x[14], 5, luts.md5_t[29])
d = md5_op(d, a, b, c, md5_g, x[ 3], 9, luts.md5_t[30])
c = md5_op(c, d, a, b, md5_g, x[ 8], 14, luts.md5_t[31])
b = md5_op(b, c, d, a, md5_g, x[13], 20, luts.md5_t[32])

-- Round three
a = md5_op(a, b, c, d, md5_h, x[ 6], 4, luts.md5_t[33])
d = md5_op(d, a, b, c, md5_h, x[ 9], 11, luts.md5_t[34])
c = md5_op(c, d, a, b, md5_h, x[12], 16, luts.md5_t[35])
b = md5_op(b, c, d, a, md5_h, x[15], 23, luts.md5_t[36])
a = md5_op(a, b, c, d, md5_h, x[ 2], 4, luts.md5_t[37])
d = md5_op(d, a, b, c, md5_h, x[ 5], 11, luts.md5_t[38])
c = md5_op(c, d, a, b, md5_h, x[ 8], 16, luts.md5_t[39])
b = md5_op(b, c, d, a, md5_h, x[11], 23, luts.md5_t[40])
a = md5_op(a, b, c, d, md5_h, x[14], 4, luts.md5_t[41])
d = md5_op(d, a, b, c, md5_h, x[ 1], 11, luts.md5_t[42])
c = md5_op(c, d, a, b, md5_h, x[ 4], 16, luts.md5_t[43])
b = md5_op(b, c, d, a, md5_h, x[ 7], 23, luts.md5_t[44])
a = md5_op(a, b, c, d, md5_h, x[10], 4, luts.md5_t[45])
d = md5_op(d, a, b, c, md5_h, x[13], 11, luts.md5_t[46])
c = md5_op(c, d, a, b, md5_h, x[16], 16, luts.md5_t[47])
b = md5_op(b, c, d, a, md5_h, x[ 3], 23, luts.md5_t[48])

-- Round four
a = md5_op(a, b, c, d, md5_i, x[ 1], 6, luts.md5_t[49])
d = md5_op(d, a, b, c, md5_i, x[ 8], 10, luts.md5_t[50])
c = md5_op(c, d, a, b, md5_i, x[15], 15, luts.md5_t[51])
b = md5_op(b, c, d, a, md5_i, x[ 6], 21, luts.md5_t[52])
a = md5_op(a, b, c, d, md5_i, x[13], 6, luts.md5_t[53])
d = md5_op(d, a, b, c, md5_i, x[ 4], 10, luts.md5_t[54])
c = md5_op(c, d, a, b, md5_i, x[11], 15, luts.md5_t[55])
b = md5_op(b, c, d, a, md5_i, x[ 2], 21, luts.md5_t[56])
a = md5_op(a, b, c, d, md5_i, x[ 9], 6, luts.md5_t[57])
d = md5_op(d, a, b, c, md5_i, x[16], 10, luts.md5_t[58])
c = md5_op(c, d, a, b, md5_i, x[ 7], 15, luts.md5_t[59])
b = md5_op(b, c, d, a, md5_i, x[14], 21, luts.md5_t[60])
a = md5_op(a, b, c, d, md5_i, x[ 5], 6, luts.md5_t[61])
d = md5_op(d, a, b, c, md5_i, x[12], 10, luts.md5_t[62])
c = md5_op(c, d, a, b, md5_i, x[ 3], 15, luts.md5_t[63])
b = md5_op(b, c, d, a, md5_i, x[10], 21, luts.md5_t[64])

context.a = u32_add(context.a, a)
context.b = u32_add(context.b, b)
context.c = u32_add(context.c, c)
context.d = u32_add(context.d, d)
end
end

local function md5_finalize(context)
assert(not context.is_finalized, 'MD5 context has already been finalized')

-- Pad (per sections 3.1 and 3.2 of RFC 1321)
local padding = '\128' .. string.rep('\0', ((56 - ((context.message_length + 1) % 64)) + 64) % 64) .. pack_le_u64(context.message_length * 8)
assert(#context.buffer + #padding == ((#context.buffer < 56) and 64 or 128))

md5_update(context, padding)

-- Concatenate (per section 3.5 of RFC 1321)
local digest = pack_le_u32(context.a) .. pack_le_u32(context.b) .. pack_le_u32(context.c) .. pack_le_u32(context.d)

-- Clean up
context.is_finalized = true
context.buffer = nil

return digest
end

local function MD5(message)
local context = md5_init()
if message then md5_update(context, message) end

local iface, memoized_digest, memoized_hexdigest = {}, nil, nil

function iface.update(message)
assert(memoized_digest == nil, 'MD5 context has already been finalized')
md5_update(context, message)
return iface -- Facilitate fluent interface
end

function iface.digest()
if memoized_digest == nil then memoized_digest = md5_finalize(context); context = nil end
return memoized_digest
end

function iface.hexdigest()
if memoized_hexdigest == nil then memoized_hexdigest = bytes_to_hex(iface.digest()) end
return memoized_hexdigest
end

return iface
end

-- Exports

local p = {}

-- Exports: for use in other libraries

p.MD5 = MD5

-- Exports: invocables

function p.md5_hexdigest(frame)
local message = make_message(frame)
return mw.hash and mw.hash.hashValue('md5', message) or MD5(message).hexdigest()
end

return p

Module:Hash - Revision history

WikiGOD at 06:03, 2 May 2021

WikiGOD: 1 revision imported

Mediawiki>Puxlit: 😂😂😂🤦🏻‍♂️🤦🏻‍♂️🤦🏻‍♂️