View difference between Paste ID: DyQFEAWa and NdDiPzvB

 -------------------------------------------------------------------------------
 -- SHA-1 secure hash computation, and HMAC-SHA1 signature computation,
 -- in pure Lua (tested on Lua 5.1)
 -- License: GPL
 --
 -- Usage:
 --   local hash_as_hex   = sha1(message)            -- returns a hex string
 --   local hash_as_data  = sha1_binary(message)     -- returns raw bytes
 --
 -- Pass sha1() a string, and it returns a hash as a 40-character hex string.
 --
 -- The "_binary" version does the same, but returns the 20-byte string of raw
 -- data that the 40-byte hex string represents.
 --
 -------------------------------------------------------------------------------
 -- based on Zet's implementation (which I found too big)
 -- > http://cube3d.de/uploads/Main/sha1.txt
 -- > > based on Jeffrey Friedl's implementation (which I found a bit too slow)
 -- > > jfriedl@yahoo.com
 -- > > http://regex.info/blog/
 -- > > Version 1 [May 28, 2009]
 -- Algorithm: http://www.itl.nist.gov/fipspubs/fip180-1.htm
 
 -------------------------------------------------------------------------------
 -------------------------------------------------------------------------------
 
 -- set this to false if you don't want to build several 64k sized tables when
 -- loading this file (takes a while but grants a boost of factor 13)
 local cfg_caching = false
 
 -- local storing of global functions (minor speedup)
 local floor,modf = math.floor,math.modf
 local char,format,rep = string.char,string.format,string.rep
 
 -- merge 4 bytes to an 32 bit word
 local function bytes_to_w32 (a,b,c,d) return a*0x1000000+b*0x10000+c*0x100+d end
 -- split a 32 bit word into four 8 bit numbers
 local function w32_to_bytes (i)
 	return floor(i/0x1000000)%0x100,floor(i/0x10000)%0x100,floor(i/0x100)%0x100,i%0x100
 end
 
 -- shift the bits of a 32 bit word. Don't use negative values for "bits"
 local function w32_rot (bits,a)
 	local b2 = 2^(32-bits)
 	local a,b = modf(a/b2)
 	return a+b*b2*(2^(bits))
 end
 
 -- caching function for functions that accept 2 arguments, both of values between
 -- 0 and 255. The function to be cached is passed, all values are calculated
 -- during loading and a function is returned that returns the cached values (only)
 local function cache2arg (fn)
 	if not cfg_caching then return fn end
 	local lut = {}
 	for i=0,0xffff do
 		local a,b = floor(i/0x100),i%0x100
 		lut[i] = fn(a,b)
 	end
 	return function (a,b)
 		return lut[a*0x100+b]
 	end
 end
 
 -- splits an 8-bit number into 8 bits, returning all 8 bits as booleans
 local function byte_to_bits (b)
 	local b = function (n)
 		local b = floor(b/n)
 		return b%2==1
 	end
 	return b(1),b(2),b(4),b(8),b(16),b(32),b(64),b(128)
 end
 
 -- builds an 8bit number from 8 booleans
 local function bits_to_byte (a,b,c,d,e,f,g,h)
 	local function n(b,x) return b and x or 0 end
 	return n(a,1)+n(b,2)+n(c,4)+n(d,8)+n(e,16)+n(f,32)+n(g,64)+n(h,128)
 end
 
 -- debug function for visualizing bits in a string
 local function bits_to_string (a,b,c,d,e,f,g,h)
 	local function x(b) return b and "1" or "0" end
 	return ("%s%s%s%s %s%s%s%s"):format(x(a),x(b),x(c),x(d),x(e),x(f),x(g),x(h))
 end
 
 -- debug function for converting a 8-bit number as bit string
 local function byte_to_bit_string (b)
 	return bits_to_string(byte_to_bits(b))
 end
 
 -- debug function for converting a 32 bit number as bit string
 local function w32_to_bit_string(a)
 	if type(a) == "string" then return a end
 	local aa,ab,ac,ad = w32_to_bytes(a)
 	local s = byte_to_bit_string
 	return ("%s %s %s %s"):format(s(aa):reverse(),s(ab):reverse(),s(ac):reverse(),s(ad):reverse()):reverse()
 end
 
 -- bitwise "and" function for 2 8bit number
 local band = cache2arg (function(a,b)
 	local A,B,C,D,E,F,G,H = byte_to_bits(b)
 	local a,b,c,d,e,f,g,h = byte_to_bits(a)
 	return bits_to_byte(
 		A and a, B and b, C and c, D and d,
 		E and e, F and f, G and g, H and h)
 end)
 
 -- bitwise "or" function for 2 8bit numbers
 local bor = cache2arg(function(a,b)
 	local A,B,C,D,E,F,G,H = byte_to_bits(b)
 	local a,b,c,d,e,f,g,h = byte_to_bits(a)
 	return bits_to_byte(
 		A or a, B or b, C or c, D or d,
 		E or e, F or f, G or g, H or h)
 end)
 
 -- bitwise "xor" function for 2 8bit numbers
 local bxor = cache2arg(function(a,b)
 	local A,B,C,D,E,F,G,H = byte_to_bits(b)
 	local a,b,c,d,e,f,g,h = byte_to_bits(a)
 	return bits_to_byte(
 		A ~= a, B ~= b, C ~= c, D ~= d,
 		E ~= e, F ~= f, G ~= g, H ~= h)
 end)
 
 -- bitwise complement for one 8bit number
 local function bnot (x)
 	return 255-(x % 256)
 end
 
 -- creates a function to combine to 32bit numbers using an 8bit combination function
 local function w32_comb(fn)
 	return function (a,b)
 		local aa,ab,ac,ad = w32_to_bytes(a)
 		local ba,bb,bc,bd = w32_to_bytes(b)
 		return bytes_to_w32(fn(aa,ba),fn(ab,bb),fn(ac,bc),fn(ad,bd))
 	end
 end
 
 -- create functions for and, xor and or, all for 2 32bit numbers
 local w32_and = w32_comb(band)
 local w32_xor = w32_comb(bxor)
 local w32_or = w32_comb(bor)
 
 -- xor function that may receive a variable number of arguments
 local function w32_xor_n (a,...)
 	local aa,ab,ac,ad = w32_to_bytes(a)
 	for i=1,select('#',...) do
 		local ba,bb,bc,bd = w32_to_bytes(select(i,...))
 		aa,ab,ac,ad = bxor(aa,ba),bxor(ab,bb),bxor(ac,bc),bxor(ad,bd)
 	end
 	return bytes_to_w32(aa,ab,ac,ad)
 end
 
 -- combining 3 32bit numbers through binary "or" operation
 local function w32_or3 (a,b,c)
 	local aa,ab,ac,ad = w32_to_bytes(a)
 	local ba,bb,bc,bd = w32_to_bytes(b)
 	local ca,cb,cc,cd = w32_to_bytes(c)
 	return bytes_to_w32(
 		bor(aa,bor(ba,ca)), bor(ab,bor(bb,cb)), bor(ac,bor(bc,cc)), bor(ad,bor(bd,cd))
 	)
 end
 
 -- binary complement for 32bit numbers
 local function w32_not (a)
 	return 4294967295-(a % 4294967296)
 end
 
 -- adding 2 32bit numbers, cutting off the remainder on 33th bit
 local function w32_add (a,b) return (a+b) % 4294967296 end
 
 -- adding n 32bit numbers, cutting off the remainder (again)
 local function w32_add_n (a,...)
 	for i=1,select('#',...) do
 		a = (a+select(i,...)) % 4294967296
 	end
 	return a
 end
 -- converting the number to a hexadecimal string
 local function w32_to_hexstring (w) return format("%08x",w) end
 
 -- calculating the SHA1 for some text
 function sha1(msg)
 	local H0,H1,H2,H3,H4 = 0x67452301,0xEFCDAB89,0x98BADCFE,0x10325476,0xC3D2E1F0
 	local msg_len_in_bits = #msg * 8
 
 	local first_append = char(0x80) -- append a '1' bit plus seven '0' bits
 
 	local non_zero_message_bytes = #msg +1 +8 -- the +1 is the appended bit 1, the +8 are for the final appended length
 	local current_mod = non_zero_message_bytes % 64
 	local second_append = current_mod>0 and rep(char(0), 64 - current_mod) or ""
 
 	-- now to append the length as a 64-bit number.
 	local B1, R1 = modf(msg_len_in_bits  / 0x01000000)
 	local B2, R2 = modf( 0x01000000 * R1 / 0x00010000)
 	local B3, R3 = modf( 0x00010000 * R2 / 0x00000100)
 	local B4	  =	0x00000100 * R3
 
 	local L64 = char( 0) .. char( 0) .. char( 0) .. char( 0) -- high 32 bits
 				.. char(B1) .. char(B2) .. char(B3) .. char(B4) --  low 32 bits
 
 	msg = msg .. first_append .. second_append .. L64
 
 	assert(#msg % 64 == 0)
 
 	local chunks = #msg / 64
 
 	local W = { }
 	local start, A, B, C, D, E, f, K, TEMP
 	local chunk = 0
 
 	while chunk < chunks do
 		--
 		-- break chunk up into W[0] through W[15]
 		--
 		start,chunk = chunk * 64 + 1,chunk + 1
 
 		for t = 0, 15 do
 			W[t] = bytes_to_w32(msg:byte(start, start + 3))
 			start = start + 4
 		end
 
 		--
 		-- build W[16] through W[79]
 		--
 		for t = 16, 79 do
 			-- For t = 16 to 79 let Wt = S1(Wt-3 XOR Wt-8 XOR Wt-14 XOR Wt-16).
 			W[t] = w32_rot(1, w32_xor_n(W[t-3], W[t-8], W[t-14], W[t-16]))
 		end
 
 		A,B,C,D,E = H0,H1,H2,H3,H4
 
 		for t = 0, 79 do
 			if t <= 19 then
 				-- (B AND C) OR ((NOT B) AND D)
 				f = w32_or(w32_and(B, C), w32_and(w32_not(B), D))
 				K = 0x5A827999
 			elseif t <= 39 then
 				-- B XOR C XOR D
 				f = w32_xor_n(B, C, D)
 				K = 0x6ED9EBA1
 			elseif t <= 59 then
 				-- (B AND C) OR (B AND D) OR (C AND D
 				f = w32_or3(w32_and(B, C), w32_and(B, D), w32_and(C, D))
 				K = 0x8F1BBCDC
 			else
 				-- B XOR C XOR D
 				f = w32_xor_n(B, C, D)
 				K = 0xCA62C1D6
 			end
 
 			-- TEMP = S5(A) + ft(B,C,D) + E + Wt + Kt;
 			A,B,C,D,E = w32_add_n(w32_rot(5, A), f, E, W[t], K),
 				A, w32_rot(30, B), C, D
 		end
 		-- Let H0 = H0 + A, H1 = H1 + B, H2 = H2 + C, H3 = H3 + D, H4 = H4 + E.
 		H0,H1,H2,H3,H4 = w32_add(H0, A),w32_add(H1, B),w32_add(H2, C),w32_add(H3, D),w32_add(H4, E)
 	end
 	local f = w32_to_hexstring
 	return f(H0) .. f(H1) .. f(H2) .. f(H3) .. f(H4)
 end
 
 local function hex_to_binary(hex)
 	return hex:gsub('..', function(hexval)
 		return string.char(tonumber(hexval, 16))
 	end)
 end
 
 function sha1_binary(msg)
 	return hex_to_binary(sha1(msg))
 end
 
 local xor_with_0x5c = {}
 local xor_with_0x36 = {}
 -- building the lookuptables ahead of time (instead of littering the source code
 -- with precalculated values)
 for i=0,0xff do
 	xor_with_0x5c[char(i)] = char(bxor(i,0x5c))
 	xor_with_0x36[char(i)] = char(bxor(i,0x36))
 end
 
 -- String Randomizer API --
 local chars = {}
 for loop = 0, 255 do
    chars[loop+1] = string.char(loop)
 end
 local string = table.concat(chars)
 
 local built = {['.'] = chars}
 
 local addLookup = function(charSet)
    local substitute = string.gsub(string, '[^'..charSet..']', '')
    local lookup = {}
    for loop = 1, string.len(substitute) do
        lookup[loop] = string.sub(substitute, loop, loop)
    end
    built[charSet] = lookup
 
    return lookup
 end
 
 function random(length, charSet)
    -- length (number)
    -- charSet (string, optional); e.g. %l%d for lower case letters and digits
 
    local charSet = charSet or '.'
 
    if charSet == '' then
       return ''
    else
       local result = {}
       local lookup = built[charSet] or addLookup(charSet)
       local range = table.getn(lookup)
 
       for loop = 1,length do
          result[loop] = lookup[math.random(1, range)]
       end
 
       return table.concat(result)
    end
 end
 
 function randomULN(length)
    return random(length, "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM0123456789")
 end
 
 -- Hashing API --
 function hashPassword(password)
    local salt = string.sub(sha1(randomULN(20)), 1, 12)
    local hash = sha1(salt .. password)
    local saltPos = string.len(password)
    if saltPos > string.len(hash) then
       saltPos = string.len(hash)
    end
    return string.sub(hash, 1, saltPos) .. salt .. string.sub(hash, saltPos + 1, string.len(hash))
 end
 
 function checkPassword(input, correct)
    local saltPos = string.len(correct)
    if saltPos > string.len(input) - 12 then
       saltPos = string.len(input) - 12
    end
    local salt = string.sub(input, saltPos + 1, saltPos + 12)
    local password = sha1(salt .. correct)
    return (password == (string.sub(input, 1, saltPos) .. string.sub(input, saltPos + 13, string.len(input))))
 end
 
 -- crypt.checkPassword(crypt.hashPassword("password"), "password")