git.zerfleddert.de Git - proxmark3-svn/blob - client/lualibs/md5.lua

   1 local md5 = {
   2   _VERSION     = "md5.lua 0.5.0",
   3   _DESCRIPTION = "MD5 computation in Lua (5.1)",
   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 floor, abs, max = math.floor, math.abs, math.max
  34 local char, byte, format, rep, sub =
  35   string.char, string.byte, string.format, string.rep, string.sub
  36
  37 local function check_int(n)
  38   -- checking not float
  39   if(n - floor(n) > 0) then
  40     error("trying to use bitwise operation on non-integer!")
  41   end
  42 end
  43
  44 local function tbl2number(tbl)
  45   local n = #tbl
  46
  47   local rslt = 0
  48   local power = 1
  49   for i = 1, n do
  50     rslt = rslt + tbl[i]*power
  51     power = power*2
  52   end
  53
  54   return rslt
  55 end
  56
  57 local function expand(tbl_m, tbl_n)
  58   local big = {}
  59   local small = {}
  60   if(#tbl_m > #tbl_n) then
  61     big = tbl_m
  62     small = tbl_n
  63   else
  64     big = tbl_n
  65     small = tbl_m
  66   end
  67   -- expand small
  68   for i = #small + 1, #big do
  69     small[i] = 0
  70   end
  71
  72 end
  73
  74 local to_bits -- needs to be declared before bit_not
  75
  76 local function bit_not(n)
  77   local tbl = to_bits(n)
  78   local size = max(#tbl, 32)
  79   for i = 1, size do
  80     if(tbl[i] == 1) then
  81       tbl[i] = 0
  82     else
  83       tbl[i] = 1
  84     end
  85   end
  86   return tbl2number(tbl)
  87 end
  88
  89 -- defined as local above
  90 to_bits = function (n)
  91   check_int(n)
  92   if(n < 0) then
  93     -- negative
  94     return to_bits(bit_not(abs(n)) + 1)
  95   end
  96   -- to bits table
  97   local tbl = {}
  98   local cnt = 1
  99   while (n > 0) do
 100     local last = math.fmod(n,2)
 101     if(last == 1) then
 102       tbl[cnt] = 1
 103     else
 104       tbl[cnt] = 0
 105     end
 106     n = (n-last)/2
 107     cnt = cnt + 1
 108   end
 109
 110   return tbl
 111 end
 112
 113 local function bit_or(m, n)
 114   local tbl_m = to_bits(m)
 115   local tbl_n = to_bits(n)
 116   expand(tbl_m, tbl_n)
 117
 118   local tbl = {}
 119   local rslt = max(#tbl_m, #tbl_n)
 120   for i = 1, rslt do
 121     if(tbl_m[i]== 0 and tbl_n[i] == 0) then
 122       tbl[i] = 0
 123     else
 124       tbl[i] = 1
 125     end
 126   end
 127
 128   return tbl2number(tbl)
 129 end
 130
 131 local function bit_and(m, n)
 132   local tbl_m = to_bits(m)
 133   local tbl_n = to_bits(n)
 134   expand(tbl_m, tbl_n)
 135
 136   local tbl = {}
 137   local rslt = max(#tbl_m, #tbl_n)
 138   for i = 1, rslt do
 139     if(tbl_m[i]== 0 or tbl_n[i] == 0) then
 140       tbl[i] = 0
 141     else
 142       tbl[i] = 1
 143     end
 144   end
 145
 146   return tbl2number(tbl)
 147 end
 148
 149 local function bit_xor(m, n)
 150   local tbl_m = to_bits(m)
 151   local tbl_n = to_bits(n)
 152   expand(tbl_m, tbl_n)
 153
 154   local tbl = {}
 155   local rslt = max(#tbl_m, #tbl_n)
 156   for i = 1, rslt do
 157     if(tbl_m[i] ~= tbl_n[i]) then
 158       tbl[i] = 1
 159     else
 160       tbl[i] = 0
 161     end
 162   end
 163
 164   return tbl2number(tbl)
 165 end
 166
 167 local function bit_rshift(n, bits)
 168   check_int(n)
 169
 170   local high_bit = 0
 171   if(n < 0) then
 172     -- negative
 173     n = bit_not(abs(n)) + 1
 174     high_bit = 2147483648 -- 0x80000000
 175   end
 176
 177   for i=1, bits do
 178     n = n/2
 179     n = bit_or(floor(n), high_bit)
 180   end
 181   return floor(n)
 182 end
 183
 184 local function bit_lshift(n, bits)
 185   check_int(n)
 186
 187   if(n < 0) then
 188     -- negative
 189     n = bit_not(abs(n)) + 1
 190   end
 191
 192   for i=1, bits do
 193     n = n*2
 194   end
 195   return bit_and(n, 4294967295) -- 0xFFFFFFFF
 196 end
 197
 198 -- convert little-endian 32-bit int to a 4-char string
 199 local function lei2str(i)
 200   local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
 201   return f(0)..f(8)..f(16)..f(24)
 202 end
 203
 204 -- convert raw string to big-endian int
 205 local function str2bei(s)
 206   local v=0
 207   for i=1, #s do
 208     v = v * 256 + byte(s, i)
 209   end
 210   return v
 211 end
 212
 213 -- convert raw string to little-endian int
 214 local function str2lei(s)
 215   local v=0
 216   for i = #s,1,-1 do
 217     v = v*256 + byte(s, i)
 218   end
 219   return v
 220 end
 221
 222 -- cut up a string in little-endian ints of given size
 223 local function cut_le_str(s,...)
 224   local o, r = 1, {}
 225   local args = {...}
 226   for i=1, #args do
 227     table.insert(r, str2lei(sub(s, o, o + args[i] - 1)))
 228     o = o + args[i]
 229   end
 230   return r
 231 end
 232
 233 local swap = function (w) return str2bei(lei2str(w)) end
 234
 235 local function hex2binaryaux(hexval)
 236   return char(tonumber(hexval, 16))
 237 end
 238
 239 local function hex2binary(hex)
 240   local result, _ = hex:gsub('..', hex2binaryaux)
 241   return result
 242 end
 243
 244 -- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
 245 -- 10/02/2001 jcw@equi4.com
 246
 247 local FF     = 0xffffffff
 248 local CONSTS = {
 249   0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
 250   0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
 251   0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
 252   0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
 253   0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
 254   0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
 255   0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
 256   0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
 257   0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
 258   0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
 259   0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
 260   0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
 261   0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
 262   0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
 263   0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
 264   0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
 265   0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
 266 }
 267
 268 local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
 269 local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
 270 local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
 271 local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
 272 local z=function (f,a,b,c,d,x,s,ac)
 273   a=bit_and(a+f(b,c,d)+x+ac,FF)
 274   -- be *very* careful that left shift does not cause rounding!
 275   return bit_or(bit_lshift(bit_and(a,bit_rshift(FF,s)),s),bit_rshift(a,32-s))+b
 276 end
 277
 278 local function transform(A,B,C,D,X)
 279   local a,b,c,d=A,B,C,D
 280   local t=CONSTS
 281
 282   a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
 283   d=z(f,d,a,b,c,X[ 1],12,t[ 2])
 284   c=z(f,c,d,a,b,X[ 2],17,t[ 3])
 285   b=z(f,b,c,d,a,X[ 3],22,t[ 4])
 286   a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
 287   d=z(f,d,a,b,c,X[ 5],12,t[ 6])
 288   c=z(f,c,d,a,b,X[ 6],17,t[ 7])
 289   b=z(f,b,c,d,a,X[ 7],22,t[ 8])
 290   a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
 291   d=z(f,d,a,b,c,X[ 9],12,t[10])
 292   c=z(f,c,d,a,b,X[10],17,t[11])
 293   b=z(f,b,c,d,a,X[11],22,t[12])
 294   a=z(f,a,b,c,d,X[12], 7,t[13])
 295   d=z(f,d,a,b,c,X[13],12,t[14])
 296   c=z(f,c,d,a,b,X[14],17,t[15])
 297   b=z(f,b,c,d,a,X[15],22,t[16])
 298
 299   a=z(g,a,b,c,d,X[ 1], 5,t[17])
 300   d=z(g,d,a,b,c,X[ 6], 9,t[18])
 301   c=z(g,c,d,a,b,X[11],14,t[19])
 302   b=z(g,b,c,d,a,X[ 0],20,t[20])
 303   a=z(g,a,b,c,d,X[ 5], 5,t[21])
 304   d=z(g,d,a,b,c,X[10], 9,t[22])
 305   c=z(g,c,d,a,b,X[15],14,t[23])
 306   b=z(g,b,c,d,a,X[ 4],20,t[24])
 307   a=z(g,a,b,c,d,X[ 9], 5,t[25])
 308   d=z(g,d,a,b,c,X[14], 9,t[26])
 309   c=z(g,c,d,a,b,X[ 3],14,t[27])
 310   b=z(g,b,c,d,a,X[ 8],20,t[28])
 311   a=z(g,a,b,c,d,X[13], 5,t[29])
 312   d=z(g,d,a,b,c,X[ 2], 9,t[30])
 313   c=z(g,c,d,a,b,X[ 7],14,t[31])
 314   b=z(g,b,c,d,a,X[12],20,t[32])
 315
 316   a=z(h,a,b,c,d,X[ 5], 4,t[33])
 317   d=z(h,d,a,b,c,X[ 8],11,t[34])
 318   c=z(h,c,d,a,b,X[11],16,t[35])
 319   b=z(h,b,c,d,a,X[14],23,t[36])
 320   a=z(h,a,b,c,d,X[ 1], 4,t[37])
 321   d=z(h,d,a,b,c,X[ 4],11,t[38])
 322   c=z(h,c,d,a,b,X[ 7],16,t[39])
 323   b=z(h,b,c,d,a,X[10],23,t[40])
 324   a=z(h,a,b,c,d,X[13], 4,t[41])
 325   d=z(h,d,a,b,c,X[ 0],11,t[42])
 326   c=z(h,c,d,a,b,X[ 3],16,t[43])
 327   b=z(h,b,c,d,a,X[ 6],23,t[44])
 328   a=z(h,a,b,c,d,X[ 9], 4,t[45])
 329   d=z(h,d,a,b,c,X[12],11,t[46])
 330   c=z(h,c,d,a,b,X[15],16,t[47])
 331   b=z(h,b,c,d,a,X[ 2],23,t[48])
 332
 333   a=z(i,a,b,c,d,X[ 0], 6,t[49])
 334   d=z(i,d,a,b,c,X[ 7],10,t[50])
 335   c=z(i,c,d,a,b,X[14],15,t[51])
 336   b=z(i,b,c,d,a,X[ 5],21,t[52])
 337   a=z(i,a,b,c,d,X[12], 6,t[53])
 338   d=z(i,d,a,b,c,X[ 3],10,t[54])
 339   c=z(i,c,d,a,b,X[10],15,t[55])
 340   b=z(i,b,c,d,a,X[ 1],21,t[56])
 341   a=z(i,a,b,c,d,X[ 8], 6,t[57])
 342   d=z(i,d,a,b,c,X[15],10,t[58])
 343   c=z(i,c,d,a,b,X[ 6],15,t[59])
 344   b=z(i,b,c,d,a,X[13],21,t[60])
 345   a=z(i,a,b,c,d,X[ 4], 6,t[61])
 346   d=z(i,d,a,b,c,X[11],10,t[62])
 347   c=z(i,c,d,a,b,X[ 2],15,t[63])
 348   b=z(i,b,c,d,a,X[ 9],21,t[64])
 349
 350   return A+a,B+b,C+c,D+d
 351 end
 352
 353 ----------------------------------------------------------------
 354
 355 function md5.sumhexa(s)
 356   local msgLen = #s
 357   local padLen = 56 - msgLen % 64
 358
 359   if msgLen % 64 > 56 then padLen = padLen + 64 end
 360
 361   if padLen == 0 then padLen = 64 end
 362
 363   s = s .. char(128) .. rep(char(0),padLen-1) .. lei2str(8*msgLen) .. lei2str(0)
 364
 365   assert(#s % 64 == 0)
 366
 367   local t = CONSTS
 368   local a,b,c,d = t[65],t[66],t[67],t[68]
 369
 370   for i=1,#s,64 do
 371     local X = cut_le_str(sub(s,i,i+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
 372     assert(#X == 16)
 373     X[0] = table.remove(X,1) -- zero based!
 374     a,b,c,d = transform(a,b,c,d,X)
 375   end
 376
 377   return format("%08x%08x%08x%08x",swap(a),swap(b),swap(c),swap(d))
 378 end
 379
 380 function md5.sum(s)
 381   return hex2binary(md5.sumhexa(s))
 382 end
 383
 384 return md5