def __init__(self, vm_id = None):
log = logging.getLogger("VirtualMachine")
vbm = vboxapi.VirtualBoxManager(None, None)
self.vbox = vbm.vbox
self.mgr = vbm.mgr
self.mach = None
self.name = None
self.username = None
self.password = None
self.mac = None
# If a virtual machine name is specified than open handle.
if vm_id is not None:
self.name = CuckooConfig().get_vm_name(vm_id)
self.username = CuckooConfig().get_vm_username(vm_id)
self.password = CuckooConfig().get_vm_password(vm_id)
try:
self.mach = self.vbox.findMachine(self.name)
log.debug("Acquired virtual machine with name \"%s\"."
% self.name)
# Acquire virtual machines' MAC address.
mac_raw = self.mach.getNetworkAdapter(0).MACAddress
mac_blocks = [mac_raw[x:x+2] for x in xrange(0, len(mac_raw), 2)]
self.mac = ':'.join(mac_blocks)
except Exception, why:
log.error("Virtual machine \"%s\" not found: %s"
% (self.name, why))
def _get_object_session():
''' get new session to vm '''
vbox, session = None, None
try:
vbox = vboxapi.VirtualBoxManager(None, None)
session = vbox.mgr.getSessionObject(vbox.vbox)
except Exception, err:
pretty.print_error(__name__, 'virtualbox: get session error ', err)
def __init__(self, mtype=None, mparams=None):
pid = current_process().ident
if _managers is None:
raise RuntimeError(
"Can not create a new manager following a system exit.")
if pid not in _managers:
with import_vboxapi() as vboxapi:
self.manager = vboxapi.VirtualBoxManager(mtype, mparams)
def _get_existing_session(vm_uuid):
''' get existing session by machine uuid '''
vbox, session = None, None
try:
vbox = vboxapi.VirtualBoxManager(None, None)
session = vbox.mgr.getSessionObject(vbox.vbox)
except Exception, err:
pretty.print_error(__name__, 'virtualbox: get session error', vm_uuid,
err)
def _get_object_session():
''' get new session to vm '''
pretty.print_debug(__name__, '_get_object_session start')
vbox, session = None, None
try:
vbox = vboxapi.VirtualBoxManager(None, None)
session = vbox.mgr.getSessionObject(vbox.vbox)
except Exception as err:
pretty.print_error(__name__, 'virtualbox: get session error ', err)
pretty.print_debug(__name__, '_get_object_session finished', vbox, session)
return vbox, session
def vb_get_manager():
"""
Creates a 'singleton' manager to communicate with a local virtualbox hypervisor.
@return:
@rtype: VirtualBoxManager
"""
global _virtualboxManager
if _virtualboxManager is None and HAS_LIBS:
salt.utils.compat.reload(vboxapi)
_virtualboxManager = vboxapi.VirtualBoxManager(None, None)
return _virtualboxManager
def vb_get_manager():
'''
Creates a 'singleton' manager to communicate with a local virtualbox hypervisor.
@return:
@rtype: VirtualBoxManager
'''
global _virtualboxManager
if _virtualboxManager is None and HAS_LIBS:
# Reloading the API extends sys.paths for subprocesses of multiprocessing, since they seem to share contexts
reload(vboxapi)
_virtualboxManager = vboxapi.VirtualBoxManager(None, None)
return _virtualboxManager
def _get_existing_session(vm_uuid):
''' get existing session by machine uuid '''
pretty.print_debug(__name__, '_get_existing_session start')
vbox, session = None, None
try:
vbox = vboxapi.VirtualBoxManager(None, None)
session = vbox.mgr.getSessionObject(vbox.vbox)
vbox.vbox.openExistingSession(session, vm_uuid)
except Exception as err:
pretty.print_error(__name__, 'virtualbox: get session error', vm_uuid,
err)
pretty.print_debug(__name__, '_get_existing_session finished', vbox,
session)
return vbox, session
def manager(self):
"""Create a default Manager object
Builds a singleton VirtualBoxManager object.
Note: It is not necessary to build this object when defining a
Session or VirtualBox object as both of these classes will default
to this object's global singleton during construction.
"""
global _manager
pid = current_process().ident
if pid not in _manager:
with _sys_path_scope():
vboxapi = import_vboxapi()
_manager[pid] = vboxapi.VirtualBoxManager(None, None)
return _manager[pid]
def init(self):
vbm = vboxapi.VirtualBoxManager('XPCOM', None)
self.ctx = {'global': vbm,
'vb' : vbm.vbox,
'mgr' : vbm.mgr,
'const' : vbm.constants,
'guest' : None} # console.guest unavailable until VM started
try:
self.mach = self.ctx['vb'].findMachine(self.vmname)
self.uuid = self.mach.id
logger.info('Using %s (uuid: %s)', self.vmname, self.uuid)
return True
except Exception as e:
logger.exception('Cannot find registered machine: %s. Error: %s', self.vmname, e)
return False
def select_vm(signal):
window = gtk.Window()
window.connect('destroy', lambda w: select_vm)
window.set_title("SELECT VIRTUAL MACHINE")
combobox = gtk.combo_box_new_text()
window.add(combobox)
virtualBoxManager = vboxapi.VirtualBoxManager(None, None)
vbox = virtualBoxManager.vbox
vboxVMList = virtualBoxManager.getArray(vbox, 'machines')
vboxNameList = [mach.name for mach in vboxVMList]
for i in vboxNameList:
combobox.append_text(str(i))
combobox.connect('changed', changed_cb)
combobox.set_active(0)
window.show_all()
return
def __init__(self, url='http://localhost/', user='', password=''):
"""Create a VirtualBoxManager WEBSERVICE manager for IVirtualBox
Options:
url - url to connect with the VirtualBox server
user - username used to auth to the VirtualBox server service
password - password used to auth to the VirtualBox server service
Example:
manager = WebServiceManager(user="******", password="******")
vbox = VirtualBox(manager=manager)
...
"""
with _sys_path_scope():
vboxapi = import_vboxapi()
params = (url, user, password)
self.manager = vboxapi.VirtualBoxManager("WEBSERVICE", params)
def vb_get_manager():
'''
Creates a 'singleton' manager to communicate with a local virtualbox hypervisor.
@return:
@rtype: VirtualBoxManager
'''
global _virtualboxManager
if _virtualboxManager is None and HAS_LIBS:
try:
from importlib import reload
except ImportError:
# If we get here, we are in py2 and reload is a built-in.
pass
# Reloading the API extends sys.paths for subprocesses of multiprocessing, since they seem to share contexts
reload(vboxapi)
_virtualboxManager = vboxapi.VirtualBoxManager(None, None)
return _virtualboxManager
def vboxmerge(machine_name):
'''
Merge snapshots using global OPTIONS.
'''
vbm = vboxapi.VirtualBoxManager(None, None)
vbox = vbm.vbox
try:
mach = vbox.findMachine(machine_name)
except pywintypes.com_error:
die('machine not found: %s' % machine_name)
out('\nmachine: %s: %s\n', mach.name, mach.id)
if mach.state != VBOX.MachineState_PoweredOff:
die('machine must be powered off')
session = vbm.mgr.getSessionObject(vbox)
print dir(vbox)
print 'session'
print dir(session)
vbox.openSession(session, mach.id)
try:
snap = mach.currentSnapshot
if snap:
if OPTIONS.discard_currentstate:
out('\ndiscarding current machine state\n')
runcmd(session.console.restoreSnapshot, snap)
skip = int(OPTIONS.skip)
count = int(OPTIONS.count)
while snap:
parent = snap.parent
if skip <= 0 and count > 0:
out('\nmerging: %s: %s\n', snap.name, snap.id)
runcmd(session.console.deleteSnapshot, snap.id)
# The deleteSnapshot API sometimes silently skips snapshots
# so test to make sure the snapshot is no longer valid.
try:
snap.id
except pywintypes.com_error:
pass
else:
if not OPTIONS.dryrun:
die('%s: %s: more than one child VDI' %
(snap.name, snap.id))
count -= 1
snap = parent
skip -= 1
else:
out('no snapshots\n')
if OPTIONS.snapshot:
# Create a base snapshot.
out('\ncreating base snapshot\n')
runcmd(session.console.takeSnapshot, 'Base',
'Created by vboxmerge')
if OPTIONS.compact:
# Compact the base VDI.
for attachment in mach.mediumAttachments:
if attachment.type == VBOX.DeviceType_HardDisk:
base = attachment.medium.base
if base.type == VBOX.MediumType_Normal:
out('\ncompacting base VDI: %s\n', base.name)
runcmd(base.compact)
finally:
session.close()
def main():
virtualBoxManager = vboxapi.VirtualBoxManager(None, None)
machines = virtualBoxManager.getArray(virtualBoxManager.vbox, 'machines')
for launcher in load():
config = generate(launcher[0], machines)
write(config, launcher)
class Kylin:
mgr = vboxapi.VirtualBoxManager()
vbox = mgr.vbox
def __init__(self, vm_name, log):
self.log = log
self.vm_name = vm_name
self.log('=== initializing')
self.vm = self.vbox.findMachine(vm_name)
self.session = self.mgr.getSessionObject(self.vbox)
self.running = False
def __del__(self):
if self.session.state != 1:
wait(self.session.console.powerDown())
def _boot(self):
self.vm = self.vbox.findMachine(self.vm_name)
self.session = self.mgr.getSessionObject(self.vbox)
self.log(' === launching')
while True:
try:
wait(
self.vm.launchVMProcess(
self.session, 'gui' if const.DEBUG else 'headless',
''))
except pywintypes.com_error: #still unlocking machine
time.sleep(.1)
else:
break
self.log(' === waiting for gs')
while True:
try:
result = self._execute('judge', const.VM_JUDGE_PSW,
'/bin/echo', ['hello', 'world'], 2)
assert result[0] == 0 and result[1].startswith(
'hello world') and not result[2]
except (AssertionError, pywintypes.com_error):
time.sleep(.1)
else:
break
def _execute(self, user, passwd, program, args, timeout=15, stdin=None):
def read_out():
process.waitFor(7, 0)
o = process.read(1, 65000, 0).tobytes().decode('utf-8', 'ignore')
stdout.append(o)
process.waitFor(8, 0)
e = process.read(2, 65000, 0).tobytes().decode('utf-8', 'ignore')
stderr.append(e)
timeout *= 1000
if self.session.state == 1:
self.session = self.mgr.openMachineSession(self.vm)
self.log(' === creating process')
with closing(
self.session.console.guest.createSession(
user, passwd, "", "kylinOJ execute session")) as gs:
while gs.status != 100:
time.sleep(.02)
process = gs.processCreate(program, [program] + args, [], [16, 32],
timeout)
process.waitFor(1, 0)
if stdin:
self.log(' === writing stdin')
process.waitFor(4, 0)
index = 0
while index < len(stdin):
array = list(map(lambda a: str(ord(a)), stdin[index:]))
wrote = process.writeArray(0, [0], array, 0)
if not wrote:
if process.status <= 100:
raise RuntimeError(
'Failed to write ANY bytes to STDIN')
else: #terminated
break
index += wrote
process.writeArray(0, [1], [], 0)
self.log(' === executing')
stdout, stderr = [], []
while process.status <= 100:
read_out()
time.sleep(0.02)
self.log(' === stopped')
read_out()
return process.exitCode, ''.join(stdout), ''.join(stderr)
def _writefile(self, user, passwd, filename, content):
if self.session.state == 1:
self.session = self.mgr.openMachineSession(self.vm)
self.log(' === initializing gs')
with closing(
self.session.console.guest.createSession(
user, passwd, "", "kylinOJ writefile session")) as gs:
while gs.status != 100:
time.sleep(.02)
self.log(' === writing')
with closing(gs.fileOpen(filename, 2, 4, 0x755)) as handler:
handler.write(content.encode('utf-8', 'ignore'), 1000)
def _readfile(self, user, passwd, filename):
if self.session.state == 1:
self.session = self.mgr.openMachineSession(self.vm)
self.log(' === initializing gs')
with closing(
self.session.console.guest.createSession(
user, passwd, "", "kylinOJ writefile session")) as gs:
while gs.status != 100:
time.sleep(.02)
self.log(' === reading')
with closing(gs.fileOpen(filename, 1, 1, 0x755)) as handler:
return handler.read(1024 * 1024, 1000).tobytes()
def restore(self):
def _pwn():
self.log(' === writing judger')
with open('vm_files/judger.cpp', 'r') as f:
self._writefile(
'root', const.VM_ROOT_PSW, '/root/judger.cpp',
f.read().replace('/*JUDGE_UID*/', const.VM_JUDGE_UID))
self.log(' === compiling judger')
code, out, err = self._execute(
'root', const.VM_ROOT_PSW, '/usr/bin/g++',
['-o', '/root/judger', '/root/judger.cpp'])
if code:
self.log('!!! errcode = %d' % code)
self.log('[STDOUT]\n%s\n[STDERR]\n%s' % (out, err))
if self.session.state != 1:
self.log('=== powering down')
wait(self.session.console.powerDown())
while self.session.state != 1:
time.sleep(.1)
self.log('=== opening session')
self.session = self.mgr.openMachineSession(self.vm)
self.vm = self.session.machine
self.log('=== restoring')
wait(
self.vm.restoreSnapshot(
self.vm.findSnapshot(const.VM_BASE_SNAPSHOT)))
wait(self.session.unlockMachine())
self.log('=== powering up')
while self.session.state != 1:
time.sleep(.1)
self._boot()
_pwn()
def _real_judge(self, source, memlimit, timelimit, datas,
callback): #mem in mb
results = []
callback({'progress': 'init'})
self.restore()
try:
self.log('=== copying user program')
self._writefile('judge', const.VM_JUDGE_PSW,
'/home/judge/program.cpp', source)
callback({'progress': 'compiling'})
self.log('=== compiling')
code, out, err = self._execute(
'judge', const.VM_JUDGE_PSW, '/usr/bin/g++', [
'-static', '-o', '/home/judge/program',
'/home/judge/program.cpp'
])
if code:
self.log('!!! errcode = %d' % code)
self.log('[STDOUT]\n%s\n[STDERR]\n%s' % (out, err))
return callback({'progress': 'done', 'result': [Result.CE]})
except Exception as e:
self.log('!!! Uncaught Error: %r' % e)
return callback({
'progress': 'done',
'result': results + [Result.SB]
})
len_datas = len(datas)
for pos, io in enumerate(datas):
try:
callback({'progress': 'judging', 'result': results})
self.log('=== judging data %d/%d' % (pos + 1, len_datas))
code, out, err = self._execute(
'root', const.VM_ROOT_PSW, '/root/judger',
[(memlimit + 1) * 1024 * 1024, timelimit + 1],
timelimit + 2, io[0])
if const.DEBUG:
self.log('[ERRCODE] %d\n[STDOUT]\n%s\n[STDERR]\n%s' %
(code, out, err))
lim = self._readfile(
'root', const.VM_ROOT_PSW,
'/root/result.txt').decode(errors='ignore')
_, runtime, *_ = lim.splitlines()
self.log('=== user program completed in %sus' % runtime)
if int(runtime) / 1000000 > timelimit:
results.append(Result.LE)
elif code and err.startswith('[JUDGER ERROR] '):
results.append(Result.SB)
elif code:
results.append(Result.RE)
elif not out:
results.append(Result.WA)
elif [x.rstrip() for x in out.rstrip().splitlines()
] == [x.rstrip() for x in io[1].rstrip().splitlines()]:
results.append(Result.AC)
elif out.replace(' ', '').replace('\n', '') == io[1].replace(
' ', '').replace('\n', ''):
results.append(Result.PE)
else:
results.append(Result.WA)
except Exception as e:
self.log('!!! Uncaught Error: %r' % e)
return callback({
'progress': 'done',
'result': results + [Result.SB]
})
return callback({'progress': 'done', 'result': results})
def judge(self, *args):
def wrapper():
self._real_judge(*args)
self.running = False
self.running = True
threading.Thread(target=wrapper).start()
except Exception as err:
logging.exception(str(err))
finally:
debugger = session.console.debugger
debugger.dumpGuestCore(
normpath(join(dirname(__file__), 'gen/coredump')), '')
if RESET_STATE:
pdwn = session.machine.saveState()
pdwn.waitForCompletion(-1)
try:
session.unlockMachine()
call(['VBoxManage', 'snapshot', 'AMA', 'restore', 'Clean'])
except Exception as err:
pass
else:
session.unlockMachine()
if __name__ == "__main__":
logging.basicConfig(format='%(levelname)s:\t%(message)s',
level=logging.DEBUG)
virtualBoxManager = vboxapi.VirtualBoxManager(None, None)
try:
vbox = virtualBoxManager.getVirtualBox()
todo = vbox.findMachine(MACH_NAME)
proc(todo, virtualBoxManager, vbox)
except Exception as err:
logging.exception(str(err))
# virtualBoxManager.closeMachineSession(session)
def __init__(self, mtype=None, mparams=None):
pid = current_process().ident
if pid not in _manager:
with import_vboxapi() as vboxapi:
self.manager = vboxapi.VirtualBoxManager(mtype, mparams)
def __getattr__(self, name):
return self.labels[name]
def __getitem__(self, value):
return self.values[value]
def __str__(self):
return "Enum(labels: %r)" % self.labels
__repr__ = __str__
try:
import vboxapi
VBM = vboxapi.VirtualBoxManager()
VB = VBM.getVirtualBox()
MachineState = Enum(VBM.constants.all_values('MachineState'))
AutostopType = Enum(VBM.constants.all_values('AutostopType'))
LockType = Enum(VBM.constants.all_values('LockType'))
OffMachineStates = (
MachineState.PoweredOff,
MachineState.Saved,
MachineState.Teleported,
MachineState.Aborted,
)
except ImportError:
vboxapi = None
class VB:
class Machine:
