def test_offsetof(self):
"""returns the offset of a member fields in a record"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
class Y(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(Y, 'b')
self.assertEquals(o, 8)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(X, 'b')
self.assertEquals(o, 16)
class X2(my_ctypes.Union):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(X2, 'b')
self.assertEquals(o, 0)
pass
def test_get_pointee_address(self):
"""tests get_pointee_address on host ctypes POINTER and haystack POINTER"""
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
self.assertEquals(my_ctypes.sizeof(X), 17)
i = X.from_buffer_copy(
b'\xAA\xAA\xBB\xBB' +
4 *
'\xBB' +
8 *
'\x11' +
'\xCC')
a = my_utils.get_pointee_address(i.p)
self.assertEquals(my_ctypes.sizeof(i.p), 8)
self.assertNotEquals(a, 0)
self.assertEquals(a, 0x1111111111111111) # 8*'\x11'
# null pointer
i = X.from_buffer_copy(
b'\xAA\xAA\xBB\xBB' +
4 *
'\xBB' +
8 *
'\x00' +
'\xCC')
pnull = my_utils.get_pointee_address(i.p)
self.assertEquals (my_utils.get_pointee_address(pnull), 0)
# change arch, and retry
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
class Y(ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
self.assertEquals(my_ctypes.sizeof(Y), 9)
i = Y.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\x11' + '\xCC')
a = my_utils.get_pointee_address(i.p)
self.assertEquals(my_ctypes.sizeof(i.p), 4)
self.assertNotEquals(a, 0)
self.assertEquals(a, 0x11111111) # 4*'\x11'
# null pointer
i = Y.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\x00' + '\xCC')
pnull = my_utils.get_pointee_address(i.p)
self.assertEquals (my_utils.get_pointee_address(pnull), 0)
# non-pointer, and void null pointer
my_ctypes = types.load_ctypes_default()
i = my_ctypes.c_int(69)
self.assertEquals (my_utils.get_pointee_address(i), 0)
pnull = my_ctypes.c_void_p(0)
self.assertEquals (my_utils.get_pointee_address(pnull), 0)
pass
def test_array2bytes(self):
"""array to bytes"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(
b'\x04' + 3 * b'\x00' + b'\x01' + 3 * b'\x00' + b'\x01' +
3 * b'\x00' + b'\x01' + 3 * b'\x00' + b'\x02' + 3 * b'\x00' +
7 * 4 * '\x00', x)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(
b'\x04' + 7 * b'\x00' + b'\x01' + 7 * b'\x00' + b'\x01' +
7 * b'\x00' + b'\x01' + 7 * b'\x00' + b'\x02' + 7 * b'\x00' +
7 * 8 * '\x00', x)
a = (my_ctypes.c_char * 12).from_buffer_copy('1234567890AB')
x = my_utils.array2bytes(a)
self.assertEquals(b'1234567890AB', x)
# mimics what ctypes gives us on memory loading.
a = b'1234567890AB'
x = my_utils.array2bytes(a)
self.assertEquals(b'1234567890AB', x)
pass
def test_offsetof(self):
"""returns the offset of a member fields in a record"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
class Y(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(Y, 'b')
self.assertEquals(o, 8)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(X, 'b')
self.assertEquals(o, 16)
class X2(my_ctypes.Union):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
o = my_utils.offsetof(X2, 'b')
self.assertEquals(o, 0)
pass
def test_container_of(self):
"""From a pointer to a member, returns the parent struct"""
# depends on offsetof
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
x = X()
x.a = 1
x.b = 2
addr_b = my_ctypes.addressof(x) + 16 # a + p
o = my_utils.container_of(addr_b, X, 'b')
self.assertEquals(my_ctypes.addressof(o), my_ctypes.addressof(x))
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
class Y(ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
y = Y()
y.a = 1
y.b = 2
addr_b = my_ctypes.addressof(y) + 8 # a + p
o = my_utils.container_of(addr_b, Y, 'b')
self.assertEquals(my_ctypes.addressof(o), my_ctypes.addressof(y))
pass
def test_array2bytes(self):
"""array to bytes"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(b'\x04' + 3 * b'\x00' +
b'\x01' + 3 * b'\x00' +
b'\x01' + 3 * b'\x00' +
b'\x01' + 3 * b'\x00' +
b'\x02' + 3 * b'\x00' +
7 * 4 * '\x00', x)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(b'\x04' + 7 * b'\x00' +
b'\x01' + 7 * b'\x00' +
b'\x01' + 7 * b'\x00' +
b'\x01' + 7 * b'\x00' +
b'\x02' + 7 * b'\x00' +
7 * 8 * '\x00', x)
a = (my_ctypes.c_char * 12).from_buffer_copy('1234567890AB')
x = my_utils.array2bytes(a)
self.assertEquals(b'1234567890AB', x)
# mimics what ctypes gives us on memory loading.
a = b'1234567890AB'
x = my_utils.array2bytes(a)
self.assertEquals(b'1234567890AB', x)
pass
def test_container_of(self):
"""From a pointer to a member, returns the parent struct"""
# depends on offsetof
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
x = X()
x.a = 1
x.b = 2
addr_b = my_ctypes.addressof(x) + 16 # a + p
o = my_utils.container_of(addr_b, X, 'b')
self.assertEquals(my_ctypes.addressof(o), my_ctypes.addressof(x))
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
class Y(ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
y = Y()
y.a = 1
y.b = 2
addr_b = my_ctypes.addressof(y) + 8 # a + p
o = my_utils.container_of(addr_b, Y, 'b')
self.assertEquals(my_ctypes.addressof(o), my_ctypes.addressof(y))
pass
def test_formatAddress(self):
my_utils64 = utils.Utils(types.build_ctypes_proxy(8, 8, 16))
my_utils32 = utils.Utils(types.build_ctypes_proxy(4, 4, 8))
x = my_utils64.formatAddress(0x12345678)
self.assertEquals('0x0000000012345678', x)
# 32b
x = my_utils32.formatAddress(0x12345678)
self.assertEquals('0x12345678', x)
def test_formatAddress(self):
my_utils64 = utils.Utils(types.build_ctypes_proxy(8, 8, 16))
my_utils32 = utils.Utils(types.build_ctypes_proxy(4, 4, 8))
x = my_utils64.formatAddress(0x12345678)
self.assertEquals('0x0000000012345678', x)
# 32b
x = my_utils32.formatAddress(0x12345678)
self.assertEquals('0x12345678', x)
def setUp(self):
from haystack import types
types.build_ctypes_proxy(4, 4, 8)
self.cpu_bits = '32'
self.os_name = 'linux'
self.tgts = []
self.process = None
self.tests = {"test1": "test-ctypes1.%d" % (32),
"test2": "test-ctypes2.%d" % (32),
"test3": "test-ctypes3.%d" % (32),
}
def setUp(self):
from haystack import types
types.build_ctypes_proxy(4, 4, 8)
self.cpu_bits = '32'
self.os_name = 'linux'
self.tgts = []
self.process = None
self.tests = {"test1": "test-ctypes1.%d" % (32),
"test2": "test-ctypes2.%d" % (32),
"test3": "test-ctypes3.%d" % (32),
}
def test_get_pointee_address(self):
"""tests get_pointee_address on host ctypes POINTER and haystack POINTER"""
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
self.assertEquals(my_ctypes.sizeof(X), 17)
i = X.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\xBB' + 8 * '\x11' +
'\xCC')
a = my_utils.get_pointee_address(i.p)
self.assertEquals(my_ctypes.sizeof(i.p), 8)
self.assertNotEquals(a, 0)
self.assertEquals(a, 0x1111111111111111) # 8*'\x11'
# null pointer
i = X.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\xBB' + 8 * '\x00' +
'\xCC')
pnull = my_utils.get_pointee_address(i.p)
self.assertEquals(my_utils.get_pointee_address(pnull), 0)
# change arch, and retry
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
class Y(ctypes.Structure):
_pack_ = True
_fields_ = [('a', my_ctypes.c_long),
('p', my_ctypes.POINTER(my_ctypes.c_int)),
('b', my_ctypes.c_ubyte)]
self.assertEquals(my_ctypes.sizeof(Y), 9)
i = Y.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\x11' + '\xCC')
a = my_utils.get_pointee_address(i.p)
self.assertEquals(my_ctypes.sizeof(i.p), 4)
self.assertNotEquals(a, 0)
self.assertEquals(a, 0x11111111) # 4*'\x11'
# null pointer
i = Y.from_buffer_copy(b'\xAA\xAA\xBB\xBB' + 4 * '\x00' + '\xCC')
pnull = my_utils.get_pointee_address(i.p)
self.assertEquals(my_utils.get_pointee_address(pnull), 0)
# non-pointer, and void null pointer
my_ctypes = types.load_ctypes_default()
i = my_ctypes.c_int(69)
self.assertEquals(my_utils.get_pointee_address(i), 0)
pnull = my_ctypes.c_void_p(0)
self.assertEquals(my_utils.get_pointee_address(pnull), 0)
pass
def test_array2bytes(self):
"""array to bytes"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(
b"\x04"
+ 3 * b"\x00"
+ b"\x01"
+ 3 * b"\x00"
+ b"\x01"
+ 3 * b"\x00"
+ b"\x01"
+ 3 * b"\x00"
+ b"\x02"
+ 3 * b"\x00"
+ 7 * 4 * "\x00",
x,
)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
a = (my_ctypes.c_long * 12)(4, 1, 1, 1, 2)
x = my_utils.array2bytes(a)
self.assertEquals(
b"\x04"
+ 7 * b"\x00"
+ b"\x01"
+ 7 * b"\x00"
+ b"\x01"
+ 7 * b"\x00"
+ b"\x01"
+ 7 * b"\x00"
+ b"\x02"
+ 7 * b"\x00"
+ 7 * 8 * "\x00",
x,
)
a = (my_ctypes.c_char * 12).from_buffer_copy("1234567890AB")
x = my_utils.array2bytes(a)
self.assertEquals(b"1234567890AB", x)
# mimics what ctypes gives us on memory loading.
a = b"1234567890AB"
x = my_utils.array2bytes(a)
self.assertEquals(b"1234567890AB", x)
pass
def test_pointer_type_cache(self):
"""test the comportment of _pointer_type_cache"""
# between reset(), we keep the reference to the ctypes modules
# and we don't the pointer cache, that we only share with the default
# ctypes proxy instance
ctypes = types.load_ctypes_default()
class X(ctypes.Structure):
pass
self.assertNotIn(X, ctypes._pointer_type_cache.keys())
ctypes.POINTER(X)
self.assertIn(X, ctypes._pointer_type_cache.keys())
# we keep the cache
self.assertIn(X, ctypes._pointer_type_cache.keys())
c4 = types.build_ctypes_proxy(4, 4, 8)
c8 = types.build_ctypes_proxy(8, 8, 16)
cd = types.load_ctypes_default()
if c4 != cd:
newarch = c4
elif c8 != cd:
newarch = c4
else:
raise RuntimeError("unmanaged case")
# cd and ctypes share a cache
self.assertIn(X, cd._pointer_type_cache.keys())
# and cd.POINTER is actually ctypes.POINTER
self.assertEquals(cd.POINTER, ctypes.POINTER)
self.assertEquals(cd._pointer_type_cache, ctypes._pointer_type_cache)
# but not other proxies
self.assertNotIn(X, newarch._pointer_type_cache.keys())
class Y(newarch.Structure):
pass
self.assertNotIn(Y, cd._pointer_type_cache.keys())
self.assertNotIn(Y, ctypes._pointer_type_cache.keys())
self.assertNotIn(Y, newarch._pointer_type_cache.keys())
newarch.POINTER(Y)
self.assertNotIn(Y, cd._pointer_type_cache.keys())
self.assertNotIn(Y, ctypes._pointer_type_cache.keys())
self.assertIn(Y, newarch._pointer_type_cache.keys())
pass
def __init__(self,
mappings,
os_name=None,
cpu_bits=None,
word_size=None,
ptr_size=None,
ld_size=None):
if mappings is None:
# we cant detect the os_name and cpu_bits without _memory_mappings
assert os_name is not None and cpu_bits is not None
elif not isinstance(mappings, list):
raise TypeError("list of IMemoryMapping expected")
elif len(mappings) == 0:
raise TypeError("list with at least one IMemoryMapping expected")
elif not isinstance(mappings[0], interfaces.IMemoryMapping):
raise TypeError("IMemoryMapping list expected")
self.__os_name = os_name or self._detect_os(mappings)
self.__cpu_bits = cpu_bits or self._detect_cpu(mappings,
self.__os_name)
self.__word_size = word_size or self._detect_word_size()
self.__ptr_size = ptr_size or self._detect_ptr_size()
self.__ld_size = ld_size or self._detect_ld_size() # long double
# win 32 bits, 4,4,8
# linux 32 bits, 4,4,12
# linux 64 bits, 8,8,16
self.__ctypes_proxy = types.build_ctypes_proxy(self.__word_size,
self.__ptr_size,
self.__ld_size)
pass
def test_load_ctypes_default(self):
"""Test if the default proxy works"""
ctypes = types.build_ctypes_proxy(4, 4, 8)
self.assertTrue(ctypes.proxy)
# test
ctypes = types.load_ctypes_default()
self.assertTrue(ctypes.proxy)
for name, value in make_types(ctypes).items():
globals()[name] = value
# default ctypes should be similar to host ctypes.
self.assertEqual(
ctypes.sizeof(arra1),
4 *
ctypes.sizeof(
ctypes.get_real_ctypes_member('c_long')))
self.assertEqual(
ctypes.sizeof(stp),
ctypes.sizeof(
ctypes.get_real_ctypes_member('c_void_p')))
self.assertEqual(
ctypes.sizeof(arra1),
4 *
ctypes.sizeof(
ctypes.c_long))
self.assertEqual(ctypes.sizeof(stp), ctypes.sizeof(ctypes.c_void_p))
return
def test_pointer_type_cache(self):
"""test the comportment of _pointer_type_cache"""
# between reset(), we keep the reference to the ctypes modules
# and we don't the pointer cache, that we only share with the default
# ctypes proxy instance
ctypes = types.load_ctypes_default()
class X(ctypes.Structure):
pass
self.assertNotIn(X, ctypes._pointer_type_cache.keys())
ctypes.POINTER(X)
self.assertIn(X, ctypes._pointer_type_cache.keys())
# we keep the cache
self.assertIn(X, ctypes._pointer_type_cache.keys())
c4 = types.build_ctypes_proxy(4, 4, 8)
c8 = types.build_ctypes_proxy(8, 8, 16)
cd = types.load_ctypes_default()
if c4 != cd:
newarch = c4
elif c8 != cd:
newarch = c4
else:
raise RuntimeError("unmanaged case")
# cd and ctypes share a cache
self.assertIn(X, cd._pointer_type_cache.keys())
# and cd.POINTER is actually ctypes.POINTER
self.assertEqual(cd.POINTER, ctypes.POINTER)
self.assertEqual(cd._pointer_type_cache, ctypes._pointer_type_cache)
# but not other proxies
self.assertNotIn(X, newarch._pointer_type_cache.keys())
class Y(newarch.Structure):
pass
self.assertNotIn(Y, cd._pointer_type_cache.keys())
self.assertNotIn(Y, ctypes._pointer_type_cache.keys())
self.assertNotIn(Y, newarch._pointer_type_cache.keys())
newarch.POINTER(Y)
self.assertNotIn(Y, cd._pointer_type_cache.keys())
self.assertNotIn(Y, ctypes._pointer_type_cache.keys())
self.assertIn(Y, newarch._pointer_type_cache.keys())
pass
def test_unpackWord(self):
# 64b
my_utils = utils.Utils(types.build_ctypes_proxy(8, 8, 16))
one = b'\x01' + 7 * b'\x00'
x = my_utils.unpackWord(one)
self.assertEquals(x, 1)
# 32b
my_utils = utils.Utils(types.build_ctypes_proxy(4, 4, 8))
one32 = b'\x01' + 3 * b'\x00'
x = my_utils.unpackWord(one32)
self.assertEquals(x, 1)
pass
# endianness
two32 = 3 * b'\x00' + '\x02'
x = my_utils.unpackWord(two32, '>')
self.assertEquals(x, 2)
pass
def test_unpackWord(self):
# 64b
my_utils = utils.Utils(types.build_ctypes_proxy(8, 8, 16))
one = b'\x01' + 7 * b'\x00'
x = my_utils.unpackWord(one)
self.assertEquals(x, 1)
# 32b
my_utils = utils.Utils(types.build_ctypes_proxy(4, 4, 8))
one32 = b'\x01' + 3 * b'\x00'
x = my_utils.unpackWord(one32)
self.assertEquals(x, 1)
pass
# endianness
two32 = 3 * b'\x00' + '\x02'
x = my_utils.unpackWord(two32, '>')
self.assertEquals(x, 2)
pass
def test_unpackWord(self):
# 64b
my_utils = utils.Utils(types.build_ctypes_proxy(8, 8, 16))
one = b"\x01" + 7 * b"\x00"
x = my_utils.unpackWord(one)
self.assertEquals(x, 1)
# 32b
my_utils = utils.Utils(types.build_ctypes_proxy(4, 4, 8))
one32 = b"\x01" + 3 * b"\x00"
x = my_utils.unpackWord(one32)
self.assertEquals(x, 1)
pass
# endianness
two32 = 3 * b"\x00" + "\x02"
x = my_utils.unpackWord(two32, ">")
self.assertEquals(x, 2)
pass
def test_bytes2array(self):
"""bytes to ctypes array"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b"\xAA" + 4 * b"\xBB" + 4 * b"\xCC" + 4 * b"\xDD" + 4 * b"\xEE" + 4 * b"\xFF"
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEquals(array[0], 0xAAAAAAAA)
self.assertEquals(len(array), 6)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b"\xAA" + 4 * b"\xBB" + 4 * b"\xCC" + 4 * b"\xDD" + 4 * b"\xEE" + 4 * b"\xFF"
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEquals(array[0], 0xBBBBBBBBAAAAAAAA)
self.assertEquals(len(array), 3)
pass
def test_set_ctypes(self):
"""Test reloading of previous defined arch-ctypes."""
x32 = types.build_ctypes_proxy(4, 4, 8)
x64 = types.build_ctypes_proxy(8, 8, 16)
win = types.build_ctypes_proxy(8, 8, 8)
ctypes = types.load_ctypes_default()
ctypes = x32
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes, x32)
self.assertEqual(ctypes.sizeof(arra1), 4 * 4)
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(double), 8)
ctypes = x64
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes, x64)
self.assertEqual(ctypes.sizeof(arra1), 4 * 8)
self.assertEqual(ctypes.sizeof(stp), 8)
self.assertEqual(ctypes.sizeof(double), 16)
ctypes = win
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes, win)
self.assertEqual(ctypes.sizeof(arra1), 4 * 8)
self.assertEqual(ctypes.sizeof(stp), 8)
self.assertEqual(ctypes.sizeof(double), 8)
ctypes = x32
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes, x32)
self.assertEqual(ctypes.sizeof(arra1), 4 * 4)
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(double), 8)
return
def test_bytes2array(self):
"""bytes to ctypes array"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b'\xAA' + 4 * b'\xBB' + 4 * b'\xCC' + \
4 * b'\xDD' + 4 * b'\xEE' + 4 * b'\xFF'
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEquals(array[0], 0xAAAAAAAA)
self.assertEquals(len(array), 6)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b'\xAA' + 4 * b'\xBB' + 4 * b'\xCC' + \
4 * b'\xDD' + 4 * b'\xEE' + 4 * b'\xFF'
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEquals(array[0], 0xBBBBBBBBAAAAAAAA)
self.assertEquals(len(array), 3)
pass
def test_bytes2array(self):
"""bytes to ctypes array"""
my_ctypes = types.build_ctypes_proxy(4, 4, 8)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b'\xAA' + 4 * b'\xBB' + 4 * b'\xCC' + \
4 * b'\xDD' + 4 * b'\xEE' + 4 * b'\xFF'
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEqual(array[0], 0xAAAAAAAA)
self.assertEqual(len(array), 6)
my_ctypes = types.build_ctypes_proxy(8, 8, 16)
my_utils = utils.Utils(my_ctypes)
bytes = 4 * b'\xAA' + 4 * b'\xBB' + 4 * b'\xCC' + \
4 * b'\xDD' + 4 * b'\xEE' + 4 * b'\xFF'
array = my_utils.bytes2array(bytes, my_ctypes.c_ulong)
self.assertEqual(array[0], 0xBBBBBBBBAAAAAAAA)
self.assertEqual(len(array), 3)
pass
def test_reload_ctypes(self):
"""Tests loading of specific arch ctypes."""
ctypes = types.build_ctypes_proxy(4, 4, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEquals(ctypes.sizeof(arra1), 4 * 4)
self.assertEquals(ctypes.sizeof(stp), 4)
self.assertEquals(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(4, 8, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEquals(ctypes.sizeof(arra1), 4 * 4)
self.assertEquals(ctypes.sizeof(stp), 8)
self.assertEquals(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(8, 4, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEquals(ctypes.sizeof(arra1), 4 * 8)
self.assertEquals(ctypes.sizeof(stp), 4)
self.assertEquals(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(8, 4, 16)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEquals(ctypes.sizeof(arra1), 4 * 8)
self.assertEquals(ctypes.sizeof(stp), 4)
self.assertEquals(ctypes.sizeof(double), 16)
# other arch
self.assertRaises(NotImplementedError, types.build_ctypes_proxy, 16, 8,
16)
return
def setUp(self):
"""Have to reload that at every test. classmethod will not work"""
# use the host ctypes with modif
ctypes = types.build_ctypes_proxy(8, 8, 16)
self.assertTrue(ctypes.proxy)
self._ctypes = ctypes
for name, value in make_types(ctypes).items():
globals()[name] = value
#
self.tests = [St, St2, SubSt2, btype, longt, voidp, stp, stpvoid, arra1,
arra2, arra3, charp, string, fptr, arra4, double, arra5,
arra6, Union, ptrUnion]
def test_reload_ctypes(self):
"""Tests loading of specific arch ctypes."""
ctypes = types.build_ctypes_proxy(4, 4, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes.sizeof(arra1), 4 * 4)
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(4, 8, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes.sizeof(arra1), 4 * 4)
self.assertEqual(ctypes.sizeof(stp), 8)
self.assertEqual(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(8, 4, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes.sizeof(arra1), 4 * 8)
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(double), 8)
# other arch
ctypes = types.build_ctypes_proxy(8, 4, 16)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertTrue(ctypes.proxy)
self.assertEqual(ctypes.sizeof(arra1), 4 * 8)
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(double), 16)
# other arch
self.assertRaises(NotImplementedError, types.build_ctypes_proxy, 16, 8, 16)
return
def test_reset_ctypes(self):
"""Test if reset gives the original types"""
ctypes = types.build_ctypes_proxy(4, 4, 8)
for name, value in make_types(ctypes).items():
globals()[name] = value
self.assertEqual(ctypes.sizeof(stp), 4)
self.assertEqual(ctypes.sizeof(arra1), 4 * 4)
import ctypes
# no CString.
self.assertRaises(AttributeError, make_types, ctypes)
self.assertIn('ctypes', '%s' % (ctypes))
self.assertFalse(hasattr(ctypes, 'proxy'))
return
def test_get_subtype(self):
my_ctypes = types.load_ctypes_default()
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_fields_ = [('p', my_ctypes.POINTER(my_ctypes.c_long))]
PX = my_ctypes.POINTER(X)
self.assertEquals(my_utils.get_subtype(PX), X)
my_ctypes = types.build_ctypes_proxy(4, 4, 8) # different arch
class Y(my_ctypes.Structure):
_fields_ = [('p', my_ctypes.POINTER(my_ctypes.c_long))]
PY = my_ctypes.POINTER(Y)
self.assertEquals(my_utils.get_subtype(PY), Y)
def test_get_subtype(self):
my_ctypes = types.load_ctypes_default()
my_utils = utils.Utils(my_ctypes)
class X(my_ctypes.Structure):
_fields_ = [('p', my_ctypes.POINTER(my_ctypes.c_long))]
PX = my_ctypes.POINTER(X)
self.assertEquals(my_utils.get_subtype(PX), X)
my_ctypes = types.build_ctypes_proxy(4, 4, 8) # different arch
class Y(my_ctypes.Structure):
_fields_ = [('p', my_ctypes.POINTER(my_ctypes.c_long))]
PY = my_ctypes.POINTER(Y)
self.assertEquals(my_utils.get_subtype(PY), Y)
def __init__(self, mappings, os_name=None, cpu_bits=None, word_size=None, ptr_size=None, ld_size=None):
if mappings is None:
# we cant detect the os_name and cpu_bits without _memory_mappings
assert os_name is not None and cpu_bits is not None
elif not isinstance(mappings, list):
raise TypeError("list of IMemoryMapping expected")
elif len(mappings) == 0:
raise TypeError("list with at least one IMemoryMapping expected")
elif not isinstance(mappings[0], interfaces.IMemoryMapping):
raise TypeError("IMemoryMapping list expected")
self.__os_name = os_name or self._detect_os(mappings)
self.__cpu_bits = cpu_bits or self._detect_cpu(mappings, self.__os_name)
self.__word_size = word_size or self._detect_word_size()
self.__ptr_size = ptr_size or self._detect_ptr_size()
self.__ld_size = ld_size or self._detect_ld_size() # long double
# win 32 bits, 4,4,8
# linux 32 bits, 4,4,12
# linux 64 bits, 8,8,16
self.__ctypes_proxy = types.build_ctypes_proxy(self.__word_size, self.__ptr_size, self.__ld_size)
pass
