def assert_ok(self, code, raises=None):
code = textwrap.dedent(code)
code = compile(code, "<%s>" % self.id(), "exec", 0, 1)
# 使用myvm解释器运行
real_stdout = sys.stdout
vm_stdout = six.StringIO()
if CAPTURE_STDOUT:
sys.stdout = vm_stdout
vm = VirtualMachine()
vm_value = vm_exc = None
try:
vm_value = vm.run_code(code)
except VirtualMachineError:
raise
except AssertionError:
raise
except Exception as e:
if not CAPTURE_EXCEPTION:
raise
vm_exc = e
sys.stderr.write("cat a exception in myvm")
finally:
real_stdout.write("-- stdout ----------\n")
real_stdout.write(vm_stdout.getvalue())
# 使用CPython解释器运行
py_stdout = six.StringIO()
sys.stdout = py_stdout
py_value = py_exc = None
globs = {}
try:
py_value = eval(code, globs, globs)
except AssertionError:
raise
except Exception as e:
py_exc = e
sys.stdout = real_stdout
self.assert_same_exception(vm_exc, py_exc)
self.assertEqual(vm_stdout.getvalue(), py_stdout.getvalue())
self.assertEqual(vm_value, py_value)
if raises:
self.assertIsInstance(vm_exc, raises)
else:
self.assertIsNone(vm_exc)
def part_two(data):
to_check = []
master = data
for i, instruction in enumerate(data):
if instruction[0] == VirtualMachine.OP_JUMP or instruction[
0] == VirtualMachine.NOP:
to_check.append(i)
for i in to_check:
data = master.copy()
instruction = data[i][0]
data[i] = (VirtualMachine.OP_JUMP if instruction == VirtualMachine.NOP
else VirtualMachine.NOP, data[i][1])
vm = VirtualMachine(data)
result = vm.run()
if result != VirtualMachine.INFINITE_LOOP:
return result
def run():
programs = [
# These are sorted from roughly easiest first to most difficult.
["add", ["data", 1], ["data", 2]],
["add", ["data", [1, 2]], ["data", [3, 4]]],
["double", ["data", 13]],
["square", ["add", ["data", 3], ["data", 4]]],
["double", ["double", ["data", 5]]],
["tag", ["data", "td"], ["data", "hello world"]],
["range", ["data", 5], ["add", ["data", 5], ["data", 10]]],
["list", ["data", 5], ["data", 7], ["add", ["data", 8], ["data", 1]]],
["len", ["data", [0, 1, 2, 3, 4]]],
["deref", ["data", 2], ["data", ["apple", "banana", "carrot", "dog"]]],
["deref", ["data", "x"], ["data", {
"x": 5,
"y": 7
}]],
["is_zero", ["data", 5]],
["is_zero", ["add", ["data", 3], ["data", -3]]],
["incr", ["data", 10]],
["decr", ["data", 10]],
["if", ["data", 1], ["data", "if-case"], ["data", "else-case"]],
[
"if", ["eq", ["data", "x"], ["data", "y"]], ["data", "if-case"],
["data", "else-case"]
],
["factorial", ["data", 5]],
["math_row", ["data", 7]],
["td", ["data", "hello"]],
["concat", ["data", ["a", "b", "c"]]],
["tr", ["list", ["td", ["data", "a"]], ["data", "<td>b</td>"]]],
["map", ["data", [1, 2, 3]], ["data", "double"]],
["math_tr", ["data", 7]],
["math_table_guts", ["range", ["data", 5], ["data", 12]]],
["table", ["data", "header_row"], ["data", ["foo", "bar"]]],
]
for program in programs:
vm = VirtualMachine(BOTS)
def callback(answer):
print '%s ->\n %s\n' % (program, str(answer))
vm.process_program(callback, program)
def write_html(answer):
open('foo.html', 'w').write(answer)
vm = VirtualMachine(BOTS)
vm.process_program(write_html,
["math_table", ["range", ["data", 5], ["data", 15]]])
def gen_bytecode():
'''
Positions of different strings:
heap_start: 8191
first_bytes: 10239
middle_bytes_hash: 10339
last_bytes_hash: 10439
enflag: 10539
error_msg: 10639
hardcoded: 10739
enter_string: 10839
memory_end: 24575
'''
code = ''
with open('asm_code', 'r') as asmfile:
code = asmfile.read()
vm = VirtualMachine(bytearray(b''))
inter = Interpreter({v.__name__: k for k, v in vm.opcode.items()})
bytecode = inter.translate(code.split('\n'))
return bytecode
from flask import Flask
from flask import render_template
from flask import redirect
from flask import request
from vm import VirtualMachine
app = Flask(__name__)
vmachine = VirtualMachine(1)
@app.route("/")
def index():
return render_template("index.html", vmachine=vmachine)
@app.route("/change_status/<new_status>")
def change_status(new_status):
if new_status == "0":
vmachine.stop()
elif new_status == "1":
vmachine.start()
elif new_status == "2":
vmachine.suspend()
return redirect("/")
@app.route("/run_process", methods=["GET", "POST"])
def run_process():
if request.method == "POST":
pid = int(request.form["pid"])
ram = float(request.form["ram"])
from flask import Flask
from flask import render_template
from flask import redirect
from flask import request
from vm import VirtualMachine
app = Flask(__name__)
vmachine = VirtualMachine("Azkaban", 16, 3.7, 1000, "Debian")
@app.route("/")
def index():
return render_template("index.html", vmachine=vmachine)
@app.route("/change_status/<new_status>")
def change_status(new_status):
if new_status == "0":
vmachine.stop()
elif new_status == "1":
vmachine.start()
elif new_status == "2":
vmachine.suspend()
else:
print("""
Elija una opción correcta por favor:
0 = Parar la máquina.
1 = Iniciarla.
2 = Suspenderla.
""")
return redirect("/")
#!/usr/bin/env python3
from vm import VirtualMachine
c = VirtualMachine()
c.load_program("add_255_3.vef")
print(c.memory_offset)
print(c.memory)
c.load_program("sub_256_3.vef")
print(c.memory_offset)
print(c.memory)
c.run()
# assert c.output()[0] == 0x22
from screen import SCREEN_SIZE, SCREEN_TOTAL_SIZE
from vm import VirtualMachine
import pygame
import sys
import os
if __name__ == "__main__":
PATH = os.path.dirname(__file__)
# get the code
filename = os.path.join(PATH, sys.argv[1])
with open(filename, "rb") as document:
raw_code = document.read()
# initialise the window
display = pygame.display.set_mode(SCREEN_TOTAL_SIZE)
# setup the vm
vm = VirtualMachine(
screen_size=SCREEN_SIZE,
screen_surface=display, # screen
instruction_set=InstructionSet,
register_set=RegisterSet(), # cpu
key_map=KEY_MAP # keyboard
)
vm.load(raw_code)
# pygame event loop
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
next(vm)
arg = parse(machine.read_address(addr + 1 + i))
args.append(arg)
if op == 'jmp':
forks.append(int(args[1]))
if op in ['jt', 'jf']:
forks.append(int(args[2]))
elif op == 'out' and args[1][0] != 'R':
args.append(chr(int(args[1])))
memo[addr] = ' '.join(args)
if op == 'ret':
break
addr += 1 + n_args
else:
addr += 1
for fork in forks:
trace(machine, fork, memo)
return memo
if __name__ == '__main__':
addr = int(sys.argv[1])
machine = VirtualMachine('input/challenge.bin')
machine.load_state('teleporter')
output = trace(machine, addr)
for key in sorted(output.keys()):
print "{}: {}".format(key, output[key])
rules = dict(X = "X+YF", Y = "FX-Y")
depth = 10
center_x = width / 2
center_y = height / 2
alf = 0.0
d_alf = 90.0
step = 10
args = (program, rules, depth, center_x, center_y, alf, d_alf, step)
vm = VirtualMachine(program=program,
rules=rules,
depth=depth,
start_x=center_x,
start_y=center_y,
start_angle=alf,
delta_angle=d_alf,
step=step
)
def drawCallback(cur_x, cur_y, new_x, new_y):
pygame.draw.line(window, (255, 255, 255), (cur_x, cur_y), (new_x, new_y))
pygame.display.update()
def eventCallback():
for event in pygame.event.get():
if event.type == QUIT:
pygame.quit()
sys.exit(0)
else:
def part_one(data):
vm = VirtualMachine(data)
return vm.run()
def __init__(self):
Cmd.__init__(self)
self.vm = VirtualMachine()
self.trace_file = None
self.breakpoints = set()
class DebugShell(Cmd):
prompt = 'VM> '
def __init__(self):
Cmd.__init__(self)
self.vm = VirtualMachine()
self.trace_file = None
self.breakpoints = set()
def do_load(self, arg):
"""load <filename>
Load the VM bytecode from <filename> to address 0"""
args = shlex.split(arg)
code_size = self.vm.load(args[0])
print "Loaded %s words" % code_size
self.vm.pc = 0
self.print_current_instruction()
def do_pc(self, arg):
"""pc <addr>
Set the program counter to address <addr>"""
args = shlex.split(arg)
self.vm.pc = int(args[0])
self.print_current_instruction()
def do_reg(self, arg):
"""reg [<n> ...]
Print the values of the specified (or all) registers"""
args = shlex.split(arg)
regs = map(int, args) if args else range(0, 8)
for r in regs:
print "R%s: %s" % (r, self.vm.registers[r])
def do_set(self, arg):
"""set <reg> <value>
Set register <reg> to <value>"""
args = shlex.split(arg)
reg = int(args[0])
value = int(args[1])
self.vm.registers[reg] = value
def do_peek(self, arg):
"""peek <addr>
Print value at memory address <addr>"""
args = shlex.split(arg)
addr = int(args[0])
print "%s: %s" % (addr, self.vm.memory[addr])
def do_poke(self, arg):
"""poke <addr> <value>
Write <value> to memory address <addr>"""
args = shlex.split(arg)
addr = int(args[0])
value = int(args[1])
self.vm.memory[addr] = value
def do_str(self, arg):
"""str <addr>
Print the length-prefixed string at <addr>"""
args = shlex.split(arg)
addr = int(args[0])
length = self.vm.memory[addr]
return ''.join(map(chr, self.vm.memory[addr + 1:addr + 1 + length]))
def do_step(self, arg):
"""step
Execute only the next instruction"""
self.vm.step()
self.print_current_instruction()
def do_break(self, arg):
"""break [<addr>]
Set a breakpoint at <addr>, or list all breakpoints"""
args = shlex.split(arg)
if args:
addr = int(args[0])
self.breakpoints.add(addr)
print "Breakpoint set at %s" % addr
else:
print "Breakpoints:"
print '\n'.join(['%s: %s' % (a, self.disassemble_one(a)) for a in self.breakpoints])
def do_unbreak(self, arg):
"""unbreak [<addr>]
Remove breakpoint from <addr> or remove all breakpoints"""
args = shlex.split(arg)
if args:
addr = int(args[0])
self.breakpoints.remove(addr)
print "Breakpoint removed from %s" % addr
else:
self.breakpoints.clear()
print "All breakpoints removed"
def do_run(self, arg):
"""run
Execute from current PC"""
try:
while 1:
if self.trace_file is not None:
self.trace()
self.vm.step()
if self.vm.pc in self.breakpoints:
raise BreakpointHit
except KeyboardInterrupt:
print "Stopped by ^C -- state may be weird"
self.print_current_instruction()
except BreakpointHit:
print "Breakpoint hit at %s" % self.vm.pc
self.print_current_instruction()
except VmHalted:
print "Halt"
def do_next(self, arg):
"""next
Execute next instruction without entering calls"""
depth = len(self.vm.call_stack)
try:
while 1:
if self.trace_file is not None:
self.trace()
self.vm.step()
if self.vm.pc in self.breakpoints:
raise BreakpointHit
if depth == len(self.vm.call_stack):
self.print_current_instruction()
return
except KeyboardInterrupt:
print "Stopped by ^C -- state may be weird"
self.print_current_instruction()
except BreakpointHit:
print "Breakpoint hit at %s" % self.vm.pc
self.print_current_instruction()
except VmHalted:
print "Halt"
def do_dis(self, arg):
"""dis <addr> [<count>]
Disassemble one or <count> instructions starting at <addr>"""
args = shlex.split(arg)
addr = int(args[0])
count = int(args[1]) if len(args) > 1 else 1
self.disassemble(addr, count)
def do_ss(self, arg):
"""ss <string>
Search for <string> in memory"""
args = shlex.split(arg)
needle = ' '.join(args)
# FIXME: This is probably horrendously inefficient
mem = ''.join(map(lambda c: chr(c if c < 256 else 0), self.vm.memory.memory))
index = mem.find(needle)
print index
def do_trace(self, arg):
"""ss off|<filename>
Turn off tracing, or begin tracing to <filename>"""
args = shlex.split(arg)
filename = args[0]
if self.trace_file is not None:
self.trace_file.close()
if filename == 'off':
self.trace_file = None
print "Tracing off"
else:
self.trace_file = file(filename, 'w')
print "Tracing to file %s" % filename
def do_dump(self, arg):
"""dump <filename>
Dump memory contents into <filename>"""
args = shlex.split(arg)
filename = args[0]
self.vm.memory.memory.tofile(file(filename, 'wb'))
def do_sdump(self, arg):
"""sdump <filename>
Dump the printable memory contents into <filename>"""
args = shlex.split(arg)
filename = args[0]
printable = set(map(ord, string.printable))
s = ''.join([chr(c) for c in self.vm.memory.memory if c in printable])
with file(filename, 'w') as f:
f.write(s)
def do_calls(self, arg):
"""calls
Show the addresses in the current call stack"""
if len(self.vm.call_stack):
print ' '.join(map(str, self.vm.call_stack))
else:
print "Empty call stack"
def do_stack(self, arg):
"""stack
Show the contents of the stack"""
if len(self.vm.stack.stack) > 0:
print ' '.join(map(str, self.vm.stack.stack))
else:
print "Empty stack"
def do_out_locations(self, arg):
locs = self.vm.out_locations.items()
sorted_locs = sorted(locs, key=lambda x: x[0])
for loc, chars in sorted_locs:
print '%s: %s' % (loc, ''.join(chars))
def do_write_calls(self, arg):
args = shlex.split(arg)
filename = args[0]
with file(filename, 'w') as f:
for dest, srcs in self.vm.calls.iteritems():
for src in srcs:
f.write('%s, %s\n' % (dest, src))
def do_EOF(self, arg):
print
return True
def print_current_instruction(self):
print '%s: %s' % (self.vm.pc, self.disassemble_one(self.vm.pc))
def trace(self):
self.trace_file.write('%s%s: %s (%s)\n' % (
' ' * len(self.vm.call_stack),
self.vm.pc,
self.disassemble_one(self.vm.pc),
', '.join(['R%s=%s' % (r, self.vm.registers[r]) for r in range(0, 8)])
))
def disassemble(self, addr, count):
while count:
try:
op_name, args = self.vm.fetch_instruction(addr)
print '%s: %s' % (addr, self.disassemble_instruction(op_name, args))
addr += 1 + len(args)
except UndefinedOpcode:
print '%s: ???' % addr
addr += 1
count -= 1
def disassemble_one(self, addr):
return self.disassemble_instruction(*self.vm.fetch_instruction(addr))
def disassemble_instruction(self, op_name, args):
return '%s %s' % (
op_name,
', '.join(map(self.disassemble_operand, args))
)
def disassemble_operand(self, value):
if 0 <= value <= 32767:
if value < 128:
return '%s (%s)' % (value, CHARS.get(value, chr(value)))
else:
return str(value)
if 32768 <= value <= 32775:
return 'R%s' % (value - 32768)
return '%s (INVALID)' % value
elif len(sys.argv) == 4 and sys.argv[1] == 'assemble':
input_file = Path(sys.argv[2])
output_file = Path(sys.argv[3])
bindata = AssembleFile(input_file)
with output_file.open('wb') as f:
bindata.tofile(f)
elif len(sys.argv) == 2 and sys.argv[1] == 'benchmark':
Benchmark('programs/conway_life.asm', 10.0, 1000000)
elif len(sys.argv) == 3 and sys.argv[1] == 'run':
sys.stdout.write(" [ ] Creating Virtual Machine...")
sys.stdout.flush()
c = VirtualMachine()
sys.stdout.write("\r [+] Virtual Machine Created...\n")
sys.stdout.flush()
sys.stdout.write(" [ ] Assembling File...")
sys.stdout.flush()
program = AssembleFile(sys.argv[2])
sys.stdout.write("\r [+] File Assembled... \n")
sys.stdout.flush()
sys.stdout.write(" [ ] Loading Binary Data...")
sys.stdout.flush()
c.LoadProgramFromData(program)
sys.stdout.write("\r [+] Binary Data Loaded... \n")
sys.stdout.flush()
print(' [*] Running Program!')
print('*' * 80 + '\n')
while not c.halted:
def run(source, args):
program = parse(source)
args = [int(arg) for arg in args]
args.reverse()
vm = VirtualMachine(program, args)
return vm.mainloop()
