def test_minimal(self):
for path in (('linux','amd64','static64.llvm.elf'), ('linux','i386','static32.llvm.elf')):
logger.warn("======== %r ========", path)
fn = helpers.getTestPath(*path)
e = Elf.Elf(file(fn))
vw = viv_cli.VivCli()
vw.loadFromFile(fn)
def parseBinary(self):
typemap = {
Elf.STT_FUNC: vtrace.SYM_FUNCTION,
Elf.STT_SECTION: vtrace.SYM_SECTION,
Elf.STT_OBJECT: vtrace.SYM_GLOBAL
}
elf = Elf.Elf(self.filename)
base = self.loadbase
# Quick pass to see if we need to assume prelink
for sec in elf.sections:
if sec.name != ".text":
continue
# Try to detect prelinked
if sec.sh_addr != sec.sh_offset:
base = 0
break
for sec in elf.sections:
self.addSymbol(sec.name, sec.sh_addr + base, sec.sh_size,
vtrace.SYM_SECTION)
for sym in elf.symbols:
self.addSymbol(sym.name, sym.st_value + base, sym.st_size,
typemap.get((sym.st_info & 0xf), vtrace.SYM_MISC))
for sym in elf.dynamic_symbols:
self.addSymbol(sym.name, sym.st_value + base, sym.st_size,
typemap.get((sym.st_info & 0xf), vtrace.SYM_MISC))
def test_files(self):
results = []
for name, test_data, path in self.data:
logger.warning("======== %r ========", name)
fn = helpers.getTestPath(*path)
e = Elf.Elf(open(fn, 'rb'))
vw = viv_cli.VivCli()
vw.loadFromFile(fn)
do_analyze(vw)
logger.debug("testing %r (%r)...", name, fn)
retval = self.do_file(vw, test_data, name)
results.append(retval)
failed = 0
for fidx, tres in enumerate(results):
for testname, testdata in tres.items():
if testdata != (0, 0):
failed += testdata[0] + testdata[1]
fname = self.data[fidx][0]
failed_old, failed_new = testdata
logger.error('%s: %s: missing: %r new: %r (%r)', fname, testname, failed_old, failed_new, fname)
self.assertEqual(failed, 0, msg="ELF Tests Failed (see error log)")
def platformParseBinary(self, filename, baseaddr, normname):
typemap = {
Elf.STT_FUNC: e_resolv.FunctionSymbol,
Elf.STT_SECTION: e_resolv.SectionSymbol,
}
fd = file(filename, 'rb')
elf = Elf.Elf(fd)
addbase = 0
if not elf.isPreLinked() and elf.isSharedObject():
addbase = baseaddr
for sec in elf.sections:
sym = e_resolv.SectionSymbol(sec.name, sec.sh_addr + addbase,
sec.sh_size, normname)
self.addSymbol(sym)
for sym in elf.symbols:
symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
sym = symclass(sym.name, sym.st_value + addbase, sym.st_size,
normname)
self.addSymbol(sym)
for sym in elf.dynamic_symbols:
symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
sym = symclass(sym.name, sym.st_value + addbase, sym.st_size,
normname)
self.addSymbol(sym)
def DISABLEtest_minimal(self):
'''
Until we've got soe decent tests for this, all this does is prolong the test time
'''
for path in (('linux','amd64','static64.llvm.elf'), ('linux','i386','static32.llvm.elf')):
logger.warning("======== %r ========", path)
fn = helpers.getTestPath(*path)
e = Elf.Elf(open(fn, 'rb'))
vw = viv_cli.VivCli()
vw.loadFromFile(fn)
def update_elfDict(game, my_elves):
global elfDict
if my_elves: # add new and delete old elves from the dictionary
for elf in my_elves: # add new
if elf.unique_id not in elfDict.keys():
elfDict[elf.unique_id] = Elf(game, elf)
for uid in elfDict.keys(): # delete old
if uid not in [elf.unique_id for elf in my_elves]:
del elfDict[uid]
else: # if we have no elves just clear the dictionary
elfDict.clear()
for elf in elfDict.values(): # update game for all elf objects
elf.game = game
def find_elf_header(self):
'''
Find and populate an ELF header structure.
Will also clear all section header information since it is invalid.
'''
self.elf.seek(0, 0)
self.elf_header = Elf.Elf(self.elf.read(64))
self.elf_header.myname = "rebuilt elf header"
self.elf_header.e_shoff = 0
self.elf_header.e_shentsize = 0
self.elf_header.e_shnum = 0
self.elf_header.e_shstrndx = 0
self.elf.seek(0, 0)
self.elf.write(self.elf_header.serialize())
def createUnitToBuy(self):
self.uniteToBuy = [
Amazon(),
Dwarf(),
Elf(),
Giant(),
Hobbit(),
Humans(),
Mago(),
Orc(),
Rats(),
Skeletton(),
Triton(),
Troll(),
Wizzard(),
Zombie()
]
shuffle(self.uniteToBuy)
def setUpClass(cls):
super(ELFTests, cls).setUpClass()
cls.tests = []
for test in data:
name, test_data, path = test
logger.warn("======== %r ========", name)
fn = helpers.getTestPath(*path)
e = Elf.Elf(file(fn))
vw = viv_cli.VivCli()
vw.loadFromFile(fn)
#vw.analyze()
vae.analyze(vw)
vagr.analyze(vw)
vaeep.analyze(vw)
vagp.analyze(vw)
cls.tests.append((name, test_data, fn, e, vw))
cls.maxDiff = None
def platformParseBinary(self, filename, baseaddr, normname):
typemap = {
Elf.STT_FUNC: e_resolv.FunctionSymbol,
Elf.STT_SECTION: e_resolv.SectionSymbol,
}
try:
fd = self.platformOpenFile(filename)
elf = Elf.Elf(fd)
except IOError:
try:
# it's possible we hit vdso or something similar
elf = Elf.elfFromMemoryObject(self, baseaddr)
except:
raise
# elf = Elf.Elf(fd)
addbase = 0
if not elf.isPreLinked() and elf.isSharedObject():
addbase = baseaddr
for sec in elf.sections:
sym = e_resolv.SectionSymbol(sec.name, sec.sh_addr + addbase,
sec.sh_size, normname)
self.addSymbol(sym)
for sym in elf.symbols:
symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
sym = symclass(sym.name, sym.st_value + addbase, sym.st_size,
normname)
self.addSymbol(sym)
for sym in elf.dynamic_symbols:
symclass = typemap.get((sym.st_info & 0xf), e_resolv.Symbol)
sym = symclass(sym.name, sym.st_value + addbase, sym.st_size,
normname)
self.addSymbol(sym)
if elf.isExecutable():
sym = e_resolv.Symbol('__entry', elf.e_entry, 0, normname)
self.addSymbol(sym)
def __init__(self, name, trace=None, verbose=False):
self.binexe = name.split(os.sep)[-1]
self.verbose = verbose
self.locsec = None
self.bin = None
self.startaddress = None
self.eip = 0
self.lastcall = (0, 0) # last target and last source address
if os.name == 'posix':
self.bin = Elf(argv[1])
self.startaddress = self.bin.e_entry
elif os.name == 'nt':
self.bin = PE(argv[1])
self.startaddress = self.bin.OPTIONAL_HEADER.AddressOfEntryPoint + self.bin.OPTIONAL_HEADER.ImageBase
self.me = getTrace()
self.me.registerNotifier(NOTIFY_EXIT, VerboseNotifier())
self.me.registerNotifier(NOTIFY_BREAK, VerboseNotifier())
self.me.registerNotifier(NOTIFY_LOAD_LIBRARY, LibraryNotifier())
self.me.addBreakpoint(
Breakpoint(self.startaddress)
) # This should get us past the loader code into the actual start of the binary
self.me.metadata['RUN'] = True
self.me.execute(argv[1])
def parseFd(vw, fd, filename=None, baseaddr=None):
fd.seek(0)
elf = Elf.Elf(fd)
return loadElfIntoWorkspace(vw, elf, filename=filename, baseaddr=baseaddr)
def parseBytes(vw, bytes, baseaddr=None):
fd = StringIO(bytes)
elf = Elf.Elf(fd)
return loadElfIntoWorkspace(vw, elf, baseaddr=baseaddr)
def parseFile(vw, filename, baseaddr=None):
fd = open(filename, 'rb')
elf = Elf.Elf(fd)
return loadElfIntoWorkspace(vw, elf, filename=filename, baseaddr=baseaddr)
def parseBytes(vw, bytes):
fd = StringIO(bytes)
elf = Elf.Elf(fd)
return loadElfIntoWorkspace(vw, elf)
def parseFile(vw, filename):
fd = file(filename, 'rb')
elf = Elf.Elf(fd)
return loadElfIntoWorkspace(vw, elf, filename=filename)
def load_level():
global book
global player
global timer
global elements
global elfs
values = {}
file_name = "./Assets/Levels/level1.dat"
if not os.path.isfile(file_name):
return False
else:
file = open(file_name, "r")
for line in file.readlines():
v_n = ""
v = ""
s = 0
for c in line:
if c == '=':
s = 1
continue
elif c == ' ':
continue
if s == 0:
v_n = v_n + c
elif s == 1:
v = v + c
values[v_n] = v.replace('\n', '')
file.close()
if not os.path.isfile(values["board"]):
return False
else:
player = Player(int(values["start_x"]), int(values["start_y"]))
elements = []
elfs = []
file = open(values["board"], "r")
i = 0
for value in file.readlines():
nu = ""
co = ""
ro = ""
s = 0
for c in value:
if c == '-':
s = s + 1
continue
if s == 0:
nu = nu + c
elif s == 1:
co = co + c
elif s == 2:
ro = ro + c
sprite = titles[int(nu)]
sprite = pygame.transform.rotate(sprite, 90 * int(ro))
elements.append(
Element(i % int(values["size_x"]),
int(i / int(values["size_x"])), sprite, int(co)))
i = i + 1
file.close()
book = Book(elements)
for i in range(3):
elfs.append(Elf(elements, player))
timer = threading.Thread(target=timer_loop)
timer.start()
