git.zerfleddert.de Git - proxmark3-svn/blob

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

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:

18 The above copyright notice and this permission notice shall be included

19 in all copies or substantial portions of the Software.

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 }

31 -- bit lib implementions

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

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

44 local function tbl2number(tbl)

45 local n = #tbl

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

54 return rslt

55 end

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

72 end

74 local to_bits -- needs to be declared before bit_not

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

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