def test_get_size(self):
heap = commonapi.heap()
with self.assertRaises(AssertionError):
heap.get_size(jit.vm, 0)
heap.alloc(jit, 20)
heap.alloc(jit, 40)
heap.alloc(jit, 50)
heap.alloc(jit, 60)
ptr = heap.alloc(jit, 10)
heap.alloc(jit, 80)
for i in xrange(10):
self.assertEqual(heap.get_size(jit.vm, ptr+i), 10)
def test_get_size(self):
heap = commonapi.heap()
with self.assertRaises(AssertionError):
heap.get_size(jit.vm, 0)
heap.alloc(jit, 20)
heap.alloc(jit, 40)
heap.alloc(jit, 50)
heap.alloc(jit, 60)
ptr = heap.alloc(jit, 10)
heap.alloc(jit, 80)
for i in xrange(10):
self.assertEqual(heap.get_size(jit.vm, ptr + i), 10)
## Memset sets the whole structure
mstruct.memset()
assert mstruct.num == 0
assert mstruct.flags == 0
assert mstruct.other.val == 0
assert mstruct.s.val == 0
assert mstruct.i.val == 0
mstruct.memset('\x11')
assert mstruct.num == 0x11111111
assert mstruct.flags == 0x11
assert mstruct.other.val == 0x11111111
assert mstruct.s.val == 0x11111111
assert mstruct.i.val == 0x11111111
# From now, just use heap.vm_alloc
my_heap = heap()
set_allocator(my_heap.vm_alloc)
# Ptr tests
## Setup for Ptr tests
# the addr field can now be omited since allocator is set
other = OtherStruct(jitter.vm)
other.foo = 0x1234
assert other.foo == 0x1234
## Basic usage
mstruct.other.val = other.get_addr()
# This also works for now:
# mstruct.other = other.get_addr()
assert mstruct.other.val == other.get_addr()
assert mstruct.other.deref == other
#! /usr/bin/env python2
"""This script is just a short example of common usages for miasm2.core.types.
For a more complete view of what is possible, tests/core/types.py covers
most of the module possibilities, and the module doc gives useful information
as well.
"""
from miasm2.analysis.machine import Machine
from miasm2.core.types import MemStruct, Self, Void, Str, Array, Ptr, \
Num, Array, set_allocator
from miasm2.os_dep.common import heap
# Instanciate a heap
my_heap = heap()
# And set it as the default memory allocator, to avoid manual allocation and
# explicit address passing to the MemType subclasses (like MemStruct)
# constructor
set_allocator(my_heap.vm_alloc)
# Let's reimplement a simple C generic linked list mapped on a VmMngr.
# All the structures and methods will use the python objects but all the data
# is in fact stored in the VmMngr
class ListNode(MemStruct):
fields = [
# The "<I" is the struct-like format of the pointer in memory, in this
# case a Little Endian 32 bits unsigned int.
# One way to handle reference to ListNode in ListNode is to use the
# special marker Self().
# You could also generate ListNode's fields with ListNode.gen_field
def __init__(self):
self.alloc_ad = self.base_addr
self.alloc_align = self.align_addr
self.heap = heap()
'''
passwd_addr = 0x141111
argzero_addr = 0x141166
sb.jitter.vm.add_memory_page(passwd_addr,PAGE_READ | PAGE_WRITE,ascii_letters[:30] + '\x00','required input')
sb.jitter.vm.add_memory_page(argzero_addr,PAGE_READ,'reverseMe\x00','argv[0] -> program path')
sb.jitter.push_uint32_t(passwd_addr) #argv[1]
sb.jitter.push_uint32_t(argzero_addr) #argv[0]
sb.jitter.push_uint32_t(0x2) #argc
'''
#Set default allocator from class heap()
set_allocator(heap().vm_alloc)
#implementing argv[] array busing core types of miasm2
argv_t = Array(Ptr("<I",Str()),3)
argv = argv_t.lval(sb.jitter.vm)
MemStrAnsi = Str().lval
argv[0].val = MemStrAnsi.from_str(sb.jitter.vm, "./reverseMe").get_addr()
argv[1].val = MemStrAnsi.from_str(sb.jitter.vm, ascii_letters[:28]).get_addr()
argv[2].val = 0
sb.jitter.push_uint32_t(argv[2].val) #argv[2]
sb.jitter.push_uint32_t(argv[1].val) #argv[1]
sb.jitter.push_uint32_t(argv[0].val) #argv[0]
sb.jitter.push_uint32_t(0x2) #argc
