mirror of https://github.com/rene-dev/stmbl.git
137 lines
3.7 KiB
Python
137 lines
3.7 KiB
Python
#!/usr/bin/python
|
|
#
|
|
# Copyright 2013 StalkR <github-misc@stalkr.net>
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
#
|
|
# 2015-01-28, Thomas Kindler <mail@t-kindler.de>:
|
|
#
|
|
# * Taken from github, added copyright header. See:
|
|
# https://github.com/StalkR/misc/blob/master/crypto/crc32.py
|
|
# http://blog.stalkr.net/2011/03/crc-32-forging.html
|
|
#
|
|
# * Changed forge() semantics to /change/ the bytes at pos instead of
|
|
# inserting there. Also return the forged CRC instead of changed data.
|
|
#
|
|
#
|
|
|
|
|
|
#https://code.google.com/p/tweakcrc/
|
|
#http://blog.stalkr.net/2011/03/crc-32-forging.html
|
|
|
|
|
|
"""Calculate and manipulate CRC32.
|
|
http://en.wikipedia.org/wiki/Cyclic_redundancy_check
|
|
-- StalkR
|
|
"""
|
|
import struct
|
|
import sys
|
|
|
|
# Polynoms in reversed notation
|
|
POLYNOMS = {
|
|
'CRC-32-IEEE': 0x04C11DB7, # 802.3
|
|
}
|
|
|
|
class Error(Exception):
|
|
pass
|
|
|
|
class CRC32(object):
|
|
"""A class to calculate and manipulate CRC32.
|
|
|
|
Use one instance per type of polynom you want to use.
|
|
Use calc() to calculate a crc32.
|
|
Use forge() to forge crc32 by adding 4 bytes anywhere.
|
|
"""
|
|
def __init__(self, type="CRC-32-IEEE"):
|
|
if type not in POLYNOMS:
|
|
raise Error("Unknown polynom. %s" % type)
|
|
self.polynom = POLYNOMS[type]
|
|
|
|
|
|
def calc_next(self, crc, data):
|
|
crc = crc ^ data
|
|
for i in range(32):
|
|
if (crc & 0x80000000):
|
|
crc = (crc << 1) ^ self.polynom
|
|
else:
|
|
crc = (crc << 1)
|
|
return crc & 0xffffffff
|
|
|
|
def calc_rev(self, crc, data):
|
|
for i in range(32):
|
|
if (crc & 1):
|
|
crc = ((crc ^ self.polynom) >> 1) | 0x80000000
|
|
else:
|
|
crc = crc >> 1
|
|
crc = crc ^ data
|
|
return crc
|
|
|
|
def calc(self, s):
|
|
"""Calculate crc32 of a string."""
|
|
|
|
crc = 0xffffffff
|
|
for i in range(0, len(s), 4):
|
|
c = struct.unpack('<L', s[i:i + 4])[0]
|
|
crc = self.calc_next(crc, c)
|
|
|
|
return crc
|
|
|
|
def rcalc(self, s, wanna_crc):
|
|
crc = wanna_crc
|
|
for i in range(len(s) - 4, -4, -4): # go from last byte to 0
|
|
c = struct.unpack('<L', s[i:i + 4])[0]
|
|
crc = self.calc_rev(crc, c)
|
|
return crc
|
|
|
|
def forge(self, wanted_crc, s, pos):
|
|
"""Forge crc32 of a string by changing 4 bytes at position pos."""
|
|
|
|
# forward calculation of CRC up to pos, sets current forward CRC state
|
|
fwd_crc = self.calc(s[:pos])
|
|
|
|
# backward calculation of CRC up to pos, sets wanted backward CRC state
|
|
bkd_crc = wanted_crc
|
|
for i in range(len(s) - 4, pos, -4): # go from last byte to pos + 4
|
|
c = struct.unpack('<L', s[i:i + 4])[0]
|
|
bkd_crc = self.calc_rev(bkd_crc, c)
|
|
|
|
# deduce the 4 bytes we need to insert
|
|
bkd_crc = self.calc_rev(bkd_crc, 0) # xor 0 to ignore data
|
|
bkd_crc = bkd_crc ^ fwd_crc
|
|
|
|
|
|
# test result
|
|
assert(self.calc(s[:pos] + struct.pack('<L', bkd_crc) + s[pos+4:]) == wanted_crc)
|
|
|
|
return bkd_crc
|
|
|
|
|
|
if __name__=='__main__':
|
|
if len(sys.argv) > 1:
|
|
arg = sys.argv[1]
|
|
else:
|
|
arg = "\x12\x34\x56\x78"
|
|
check = "\xdf\x8a\x8a\x2b"
|
|
|
|
# CRC32 with default polynom
|
|
crc = CRC32().calc(arg[::-1])
|
|
print "CRC32(%s) = 0x%08x" % (repr(arg), crc)
|
|
assert(struct.pack('<L', crc) == check[::-1])
|
|
|
|
rcrc = CRC32().rcalc(arg[::-1], crc)
|
|
print "RCRC32(%s, 0x%08x) = 0x%08x" % (repr(arg), crc, rcrc)
|
|
assert(rcrc == 0xffffffff)
|
|
|
|
|