API tools faq
paste
Advertisement
i6_quadcore

md5

i6_quadcore
Mar 23rd, 2025
561
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 12.69 KB | None | 0 0
raw download clone embed print report
  1. local md5 = {
  2.     _VERSION     = "md5.lua 1.1.0",
  3.     _DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)",
  4.     _URL         = "https://github.com/kikito/md5.lua",
  5.     _LICENSE     = [[
  6.       MIT LICENSE
  7.  
  8.       Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software
  9.  
  10.       Permission is hereby granted, free of charge, to any person obtaining a
  11.       copy of this software and associated documentation files (the
  12.       "Software"), to deal in the Software without restriction, including
  13.       without limitation the rights to use, copy, modify, merge, publish,
  14.       distribute, sublicense, and/or sell copies of the Software, and to
  15.       permit persons to whom the Software is furnished to do so, subject to
  16.       the following conditions:
  17.  
  18.       The above copyright notice and this permission notice shall be included
  19.       in all copies or substantial portions of the Software.
  20.  
  21.       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  22.       OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23.       MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  24.       IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  25.       CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  26.       TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  27.       SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28.     ]]
  29.   }
  30.  
  31.   -- bit lib implementions
  32.  
  33.   local char, byte, format, rep, sub =
  34.     string.char, string.byte, string.format, string.rep, string.sub
  35.   local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift
  36.  
  37.   local ok, bit = pcall(require, 'bit')
  38.   local ok_ffi, ffi = pcall(require, 'ffi')
  39.   if ok then
  40.     bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift
  41.   else
  42.     ok, bit = pcall(require, 'bit32')
  43.  
  44.     if ok then
  45.  
  46.       bit_not = bit.bnot
  47.  
  48.       local tobit = function(n)
  49.         return n <= 0x7fffffff and n or -(bit_not(n) + 1)
  50.       end
  51.  
  52.       local normalize = function(f)
  53.         return function(a,b) return tobit(f(tobit(a), tobit(b))) end
  54.       end
  55.  
  56.       bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor)
  57.       bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift)
  58.  
  59.     else
  60.  
  61.       local function tbl2number(tbl)
  62.         local result = 0
  63.         local power = 1
  64.         for i = 1, #tbl do
  65.           result = result + tbl[i] * power
  66.           power = power * 2
  67.         end
  68.         return result
  69.       end
  70.  
  71.       local function expand(t1, t2)
  72.         local big, small = t1, t2
  73.         if(#big < #small) then
  74.           big, small = small, big
  75.         end
  76.         -- expand small
  77.         for i = #small + 1, #big do
  78.           small[i] = 0
  79.         end
  80.       end
  81.  
  82.       local to_bits -- needs to be declared before bit_not
  83.  
  84.       bit_not = function(n)
  85.         local tbl = to_bits(n)
  86.         local size = math.max(#tbl, 32)
  87.         for i = 1, size do
  88.           if(tbl[i] == 1) then
  89.             tbl[i] = 0
  90.           else
  91.             tbl[i] = 1
  92.           end
  93.         end
  94.         return tbl2number(tbl)
  95.       end
  96.  
  97.       -- defined as local above
  98.       to_bits = function (n)
  99.         if(n < 0) then
  100.           -- negative
  101.           return to_bits(bit_not(math.abs(n)) + 1)
  102.         end
  103.         -- to bits table
  104.         local tbl = {}
  105.         local cnt = 1
  106.         local last
  107.         while n > 0 do
  108.           last      = n % 2
  109.           tbl[cnt]  = last
  110.           n         = (n-last)/2
  111.           cnt       = cnt + 1
  112.         end
  113.  
  114.         return tbl
  115.       end
  116.  
  117.       bit_or = function(m, n)
  118.         local tbl_m = to_bits(m)
  119.         local tbl_n = to_bits(n)
  120.         expand(tbl_m, tbl_n)
  121.  
  122.         local tbl = {}
  123.         for i = 1, #tbl_m do
  124.           if(tbl_m[i]== 0 and tbl_n[i] == 0) then
  125.             tbl[i] = 0
  126.           else
  127.             tbl[i] = 1
  128.           end
  129.         end
  130.  
  131.         return tbl2number(tbl)
  132.       end
  133.  
  134.       bit_and = function(m, n)
  135.         local tbl_m = to_bits(m)
  136.         local tbl_n = to_bits(n)
  137.         expand(tbl_m, tbl_n)
  138.  
  139.         local tbl = {}
  140.         for i = 1, #tbl_m do
  141.           if(tbl_m[i]== 0 or tbl_n[i] == 0) then
  142.             tbl[i] = 0
  143.           else
  144.             tbl[i] = 1
  145.           end
  146.         end
  147.  
  148.         return tbl2number(tbl)
  149.       end
  150.  
  151.       bit_xor = function(m, n)
  152.         local tbl_m = to_bits(m)
  153.         local tbl_n = to_bits(n)
  154.         expand(tbl_m, tbl_n)
  155.  
  156.         local tbl = {}
  157.         for i = 1, #tbl_m do
  158.           if(tbl_m[i] ~= tbl_n[i]) then
  159.             tbl[i] = 1
  160.           else
  161.             tbl[i] = 0
  162.           end
  163.         end
  164.  
  165.         return tbl2number(tbl)
  166.       end
  167.  
  168.       bit_rshift = function(n, bits)
  169.         local high_bit = 0
  170.         if(n < 0) then
  171.           -- negative
  172.           n = bit_not(math.abs(n)) + 1
  173.           high_bit = 0x80000000
  174.         end
  175.  
  176.         local floor = math.floor
  177.  
  178.         for i=1, bits do
  179.           n = n/2
  180.           n = bit_or(floor(n), high_bit)
  181.         end
  182.         return floor(n)
  183.       end
  184.  
  185.       bit_lshift = function(n, bits)
  186.         if(n < 0) then
  187.           -- negative
  188.           n = bit_not(math.abs(n)) + 1
  189.         end
  190.  
  191.         for i=1, bits do
  192.           n = n*2
  193.         end
  194.         return bit_and(n, 0xFFFFFFFF)
  195.       end
  196.     end
  197.   end
  198.  
  199.   -- convert little-endian 32-bit int to a 4-char string
  200.   local lei2str
  201.   -- function is defined this way to allow full jit compilation (removing UCLO instruction in LuaJIT)
  202.   if ok_ffi then
  203.     local ct_IntType = ffi.typeof("int[1]")
  204.     lei2str = function(i) return ffi.string(ct_IntType(i), 4) end
  205.   else
  206.     lei2str = function (i)
  207.       local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
  208.       return f(0)..f(8)..f(16)..f(24)
  209.     end
  210.   end
  211.  
  212.  
  213.  
  214.   -- convert raw string to big-endian int
  215.   local function str2bei(s)
  216.     local v=0
  217.     for i=1, #s do
  218.       v = v * 256 + byte(s, i)
  219.     end
  220.     return v
  221.   end
  222.  
  223.   -- convert raw string to little-endian int
  224.   local str2lei
  225.  
  226.   if ok_ffi then
  227.     local ct_constcharptr = ffi.typeof("const char*")
  228.     local ct_constintptr = ffi.typeof("const int*")
  229.     str2lei = function(s)
  230.       local int = ct_constcharptr(s)
  231.       return ffi.cast(ct_constintptr, int)[0]
  232.     end
  233.   else
  234.     str2lei = function(s)
  235.       local v=0
  236.       for i = #s,1,-1 do
  237.         v = v*256 + byte(s, i)
  238.       end
  239.       return v
  240.       end
  241.   end
  242.  
  243.  
  244.   -- cut up a string in little-endian ints of given size
  245.   local function cut_le_str(s)
  246.     return {
  247.       str2lei(sub(s, 1, 4)),
  248.       str2lei(sub(s, 5, 8)),
  249.       str2lei(sub(s, 9, 12)),
  250.       str2lei(sub(s, 13, 16)),
  251.       str2lei(sub(s, 17, 20)),
  252.       str2lei(sub(s, 21, 24)),
  253.       str2lei(sub(s, 25, 28)),
  254.       str2lei(sub(s, 29, 32)),
  255.       str2lei(sub(s, 33, 36)),
  256.       str2lei(sub(s, 37, 40)),
  257.       str2lei(sub(s, 41, 44)),
  258.       str2lei(sub(s, 45, 48)),
  259.       str2lei(sub(s, 49, 52)),
  260.       str2lei(sub(s, 53, 56)),
  261.       str2lei(sub(s, 57, 60)),
  262.       str2lei(sub(s, 61, 64)),
  263.     }
  264.   end
  265.  
  266.   -- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
  267.   -- 10/02/2001 jcw@equi4.com
  268.  
  269.   local CONSTS = {
  270.     0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
  271.     0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
  272.     0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
  273.     0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
  274.     0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
  275.     0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
  276.     0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
  277.     0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
  278.     0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
  279.     0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
  280.     0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
  281.     0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
  282.     0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
  283.     0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
  284.     0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
  285.     0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
  286.     0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
  287.   }
  288.  
  289.   local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
  290.   local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
  291.   local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
  292.   local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
  293.   local z=function (ff,a,b,c,d,x,s,ac)
  294.     a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF)
  295.     -- be *very* careful that left shift does not cause rounding!
  296.     return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b
  297.   end
  298.  
  299.   local function transform(A,B,C,D,X)
  300.     local a,b,c,d=A,B,C,D
  301.     local t=CONSTS
  302.  
  303.     a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
  304.     d=z(f,d,a,b,c,X[ 1],12,t[ 2])
  305.     c=z(f,c,d,a,b,X[ 2],17,t[ 3])
  306.     b=z(f,b,c,d,a,X[ 3],22,t[ 4])
  307.     a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
  308.     d=z(f,d,a,b,c,X[ 5],12,t[ 6])
  309.     c=z(f,c,d,a,b,X[ 6],17,t[ 7])
  310.     b=z(f,b,c,d,a,X[ 7],22,t[ 8])
  311.     a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
  312.     d=z(f,d,a,b,c,X[ 9],12,t[10])
  313.     c=z(f,c,d,a,b,X[10],17,t[11])
  314.     b=z(f,b,c,d,a,X[11],22,t[12])
  315.     a=z(f,a,b,c,d,X[12], 7,t[13])
  316.     d=z(f,d,a,b,c,X[13],12,t[14])
  317.     c=z(f,c,d,a,b,X[14],17,t[15])
  318.     b=z(f,b,c,d,a,X[15],22,t[16])
  319.  
  320.     a=z(g,a,b,c,d,X[ 1], 5,t[17])
  321.     d=z(g,d,a,b,c,X[ 6], 9,t[18])
  322.     c=z(g,c,d,a,b,X[11],14,t[19])
  323.     b=z(g,b,c,d,a,X[ 0],20,t[20])
  324.     a=z(g,a,b,c,d,X[ 5], 5,t[21])
  325.     d=z(g,d,a,b,c,X[10], 9,t[22])
  326.     c=z(g,c,d,a,b,X[15],14,t[23])
  327.     b=z(g,b,c,d,a,X[ 4],20,t[24])
  328.     a=z(g,a,b,c,d,X[ 9], 5,t[25])
  329.     d=z(g,d,a,b,c,X[14], 9,t[26])
  330.     c=z(g,c,d,a,b,X[ 3],14,t[27])
  331.     b=z(g,b,c,d,a,X[ 8],20,t[28])
  332.     a=z(g,a,b,c,d,X[13], 5,t[29])
  333.     d=z(g,d,a,b,c,X[ 2], 9,t[30])
  334.     c=z(g,c,d,a,b,X[ 7],14,t[31])
  335.     b=z(g,b,c,d,a,X[12],20,t[32])
  336.  
  337.     a=z(h,a,b,c,d,X[ 5], 4,t[33])
  338.     d=z(h,d,a,b,c,X[ 8],11,t[34])
  339.     c=z(h,c,d,a,b,X[11],16,t[35])
  340.     b=z(h,b,c,d,a,X[14],23,t[36])
  341.     a=z(h,a,b,c,d,X[ 1], 4,t[37])
  342.     d=z(h,d,a,b,c,X[ 4],11,t[38])
  343.     c=z(h,c,d,a,b,X[ 7],16,t[39])
  344.     b=z(h,b,c,d,a,X[10],23,t[40])
  345.     a=z(h,a,b,c,d,X[13], 4,t[41])
  346.     d=z(h,d,a,b,c,X[ 0],11,t[42])
  347.     c=z(h,c,d,a,b,X[ 3],16,t[43])
  348.     b=z(h,b,c,d,a,X[ 6],23,t[44])
  349.     a=z(h,a,b,c,d,X[ 9], 4,t[45])
  350.     d=z(h,d,a,b,c,X[12],11,t[46])
  351.     c=z(h,c,d,a,b,X[15],16,t[47])
  352.     b=z(h,b,c,d,a,X[ 2],23,t[48])
  353.  
  354.     a=z(i,a,b,c,d,X[ 0], 6,t[49])
  355.     d=z(i,d,a,b,c,X[ 7],10,t[50])
  356.     c=z(i,c,d,a,b,X[14],15,t[51])
  357.     b=z(i,b,c,d,a,X[ 5],21,t[52])
  358.     a=z(i,a,b,c,d,X[12], 6,t[53])
  359.     d=z(i,d,a,b,c,X[ 3],10,t[54])
  360.     c=z(i,c,d,a,b,X[10],15,t[55])
  361.     b=z(i,b,c,d,a,X[ 1],21,t[56])
  362.     a=z(i,a,b,c,d,X[ 8], 6,t[57])
  363.     d=z(i,d,a,b,c,X[15],10,t[58])
  364.     c=z(i,c,d,a,b,X[ 6],15,t[59])
  365.     b=z(i,b,c,d,a,X[13],21,t[60])
  366.     a=z(i,a,b,c,d,X[ 4], 6,t[61])
  367.     d=z(i,d,a,b,c,X[11],10,t[62])
  368.     c=z(i,c,d,a,b,X[ 2],15,t[63])
  369.     b=z(i,b,c,d,a,X[ 9],21,t[64])
  370.  
  371.     return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF),
  372.            bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF)
  373.   end
  374.  
  375.   ----------------------------------------------------------------
  376.  
  377.   local function md5_update(self, s)
  378.     self.pos = self.pos + #s
  379.     s = self.buf .. s
  380.     for ii = 1, #s - 63, 64 do
  381.       local X = cut_le_str(sub(s,ii,ii+63))
  382.       assert(#X == 16)
  383.       X[0] = table.remove(X,1) -- zero based!
  384.       self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X)
  385.     end
  386.     self.buf = sub(s, math.floor(#s/64)*64 + 1, #s)
  387.     return self
  388.   end
  389.  
  390.   local function md5_finish(self)
  391.     local msgLen = self.pos
  392.     local padLen = 56 - msgLen % 64
  393.  
  394.     if msgLen % 64 > 56 then padLen = padLen + 64 end
  395.  
  396.     if padLen == 0 then padLen = 64 end
  397.  
  398.     local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000))
  399.     md5_update(self, s)
  400.  
  401.     assert(self.pos % 64 == 0)
  402.     return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d)
  403.   end
  404.  
  405.   ----------------------------------------------------------------
  406.  
  407.   function md5.new()
  408.     return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68],
  409.              pos = 0,
  410.              buf = '',
  411.              update = md5_update,
  412.              finish = md5_finish }
  413.   end
  414.  
  415.   function md5.tohex(s)
  416.     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)))
  417.   end
  418.  
  419.   function md5.sum(s)
  420.     return md5.new():update(s):finish()
  421.   end
  422.  
  423.   function md5.sumhexa(s)
  424.     return md5.tohex(md5.sum(s))
  425.   end
  426.  
  427.   return md5
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!