dpyproxy 2.2.0__py3-none-any.whl

network/protocols/Http.py

@@ -0,0 +1,109 @@
+from enumerators.HttpMethod import HttpMethod
+from exception.ParserException import ParserException
+from network.NetworkAddress import NetworkAddress
+from network.tcp.WrappedTcpSocket import WrappedTcpSocket
+
+
+class Http:
+    """
+    Implements methods to parse HTTP messages.
+    """
+
+    @staticmethod
+    def is_valid_http(wrapped_socket: WrappedTcpSocket) -> bool:
+        try:
+            Http._parse_http_method(wrapped_socket, HttpMethod.all(), True)
+            return True
+        except ParserException:
+            return False
+
+    @staticmethod
+    def _parse_http_method(wrapped_socket: WrappedTcpSocket, methods: list[str], peek: bool = False) -> (str, int, str):
+        """
+        Reads the first line of a http method to parse the domain from it.
+        :return: host and port in the method, defaults to port 80 if no port found
+        """
+        try:
+            # read complete message
+            message = wrapped_socket.read_until([b"\n\n", b"\r\n\r\n"], 500, peek).decode("ASCII")
+            # extract first line, assume that \r\n are at least used coherently in the message
+            if "\r\n" in message:
+                first_line = message.split("\r\n")[0]
+            else:
+                first_line = message.split("\n")[0]
+        except UnicodeDecodeError as e:
+            raise ParserException(f"Could not decode ASCII in first line of HTTP request with exception {e}")
+        # check for any method
+        parsed_method = False
+        for method in methods:
+            if first_line.upper().startswith(f"{method.upper()} "):
+                parsed_method = True
+        if not parsed_method:
+            raise ParserException(f"Not a {methods} request")
+        if first_line.count(" ") not in [1, 2]:
+            raise ParserException("Not a valid HTTP request, could not determine target URI")
+        if first_line.count(" ") == 1:
+            # HTTP/0.9
+            _, uri = first_line.split(" ")
+            version = "HTTP/0.9"
+        else:
+            _, uri, version = first_line.split(" ")
+        if version.upper() != "HTTP/1.1" and version.upper() != "HTTP/1.0" and version.upper() != "HTTP/0.9":
+            raise ParserException("Not a valid HTTP request, only HTTP/0.9, HTTP/1.0, and HTTP/1.1 supported")
+        host, _, port = Http.parse_uri(uri)
+        return host, port, version
+
+    @staticmethod
+    def read_http_get(wrapped_socket: WrappedTcpSocket) -> (str, int, str):
+        """
+        Reads the first line of a http get request.
+        :return: host, port, and version from the http get request.
+        """
+        return Http._parse_http_method(wrapped_socket, ["GET"], True)
+
+    @staticmethod
+    def read_http_connect(wrapped_socket: WrappedTcpSocket) -> (str, int, str):
+        """
+        Reads the first line of a http connect request.
+        :return: host, port, and http version from the http connect request.
+        """
+        return Http._parse_http_method(wrapped_socket, ["CONNECT"], False)
+
+    @staticmethod
+    def parse_uri(uri: str) -> (str, str, int):
+        """
+        Parses a URI into its host, path and port components.
+        Parameters are currently not parsed.
+        :param uri: uri to parse
+        :return: host, path, port
+        """
+        if "://" in uri:
+            # remove protocol prefix if present
+            uri = uri.split("://")[1]
+
+        if "/" in uri:
+            # split host and path
+            uri, path = uri.split("/", 1)
+            path = "/" + path
+        else:
+            path = "/"
+
+        if ":" in uri:
+            # split host and port
+            uri, port = uri.split(":")
+            port = int(port)
+        else:
+            port = 80
+
+        return uri, path, port
+
+    @staticmethod
+    def connect_message(server_address: NetworkAddress, version: str) -> bytes:
+        return (
+            f"CONNECT {server_address.host}:{server_address.port} {version}\n"
+            f"Host: {server_address.host}:{server_address.port}\n\n".encode("ASCII")
+        )
+
+    @staticmethod
+    def http_200_ok(version: str) -> bytes:
+        return f"{version} 200 OK\n\n".encode("ASCII")

network/protocols/Socksv4.py

@@ -0,0 +1,70 @@
+from exception.ParserException import ParserException
+from network.NetworkAddress import NetworkAddress
+from network.tcp.WrappedTcpSocket import WrappedTcpSocket
+from util.constants import SOCKSv4_HEADER
+from util.Util import is_valid_ipv4_address
+
+
+class Socksv4:
+    """
+    Implements SOCKSv4a protocol
+    """
+
+    REQUEST_MODE = b"\01"
+    BIND_MODE = b"\02"
+
+    @staticmethod
+    def read_socks4(connection_socket: WrappedTcpSocket) -> tuple[str, int]:
+
+        version = connection_socket.recv(1)
+        if version != SOCKSv4_HEADER:
+            raise ParserException("Not a SOCKSv4 request")
+
+        mode = connection_socket.recv(1)
+        if mode == Socksv4.BIND_MODE:
+            raise ParserException("BIND mode not supported")
+        if mode != Socksv4.REQUEST_MODE:
+            raise ParserException(f"Socks mode {mode} not supported")
+
+        port = int.from_bytes(connection_socket.recv(2), byteorder="big")
+        if not 0 <= port <= 65535:
+            raise ParserException(f"Invalid port {port}")
+
+        # str ip from bytes
+        ip = ".".join(f"{c}" for c in connection_socket.recv(4))
+
+        # ignore user_id but parse bytes until null byte
+        connection_socket.read_until([b"\x00"])
+
+        # socksv4a allows for domain/ip? behind user id
+        if ip.startswith("0.0.0."):
+            ip = connection_socket.read_until([b"\x00"])[:-1].decode("utf-8")
+
+        return ip, port
+
+    @staticmethod
+    def socks4_request(server_address: NetworkAddress):
+        if not is_valid_ipv4_address(server_address.host):
+            # Socksv4a domain encoding
+            return (
+                SOCKSv4_HEADER
+                + b"\x01"
+                + server_address.port.to_bytes(2, byteorder="big")
+                + "0.0.0.1".encode("'utf-8")
+                + b"\x00"
+                + server_address.host.encode("utf-8")
+                + b"\x00"
+            )
+        else:
+            # Socksv4 ip encoding
+            return (
+                SOCKSv4_HEADER
+                + b"\x01"
+                + server_address.port.to_bytes(2, byteorder="big")
+                + bytes([int(i) for i in server_address.host.split(".")])
+                + b"\x00"
+            )
+
+    @staticmethod
+    def socks4_ok() -> bytes:
+        return b"\00\x5a\xff\xff\xff\xff\xff\xff"

network/protocols/Socksv5.py

@@ -0,0 +1,106 @@
+import socket
+
+from exception.ParserException import ParserException
+from network.NetworkAddress import NetworkAddress
+from network.tcp.WrappedTcpSocket import WrappedTcpSocket
+from util.constants import SOCKSv5_HEADER
+from util.Util import is_valid_ipv4_address
+
+
+class Socksv5:
+    """
+    Implements SOCKSv5 protocol, only supports no auth
+    """
+
+    REQUEST_MODE = b"\x01"
+    BIND_MODE = b"\x02"
+    UDP_PORT = b"\x03"
+    RESERVED_BYTE = b"\x00"
+    NO_AUTH = b"\x00"
+
+    @staticmethod
+    def read_socks5(connection_socket: WrappedTcpSocket) -> tuple[str, int]:
+
+        # read connection methods
+        version = connection_socket.recv(1)
+        if version != SOCKSv5_HEADER:
+            raise ParserException("Not a SOCKSv5 request")
+
+        number_authentication_methods = int.from_bytes(connection_socket.recv(1), byteorder="big")
+        if number_authentication_methods == 0:
+            connection_socket.send(SOCKSv5_HEADER + b"\xff")
+            raise ParserException("No auth method provided")
+
+        authentication_methods = connection_socket.read(number_authentication_methods)
+        if Socksv5.NO_AUTH not in authentication_methods:
+            connection_socket.send(SOCKSv5_HEADER + b"\xff")
+            raise ParserException("No auth method not supported by client")
+
+        # always choose no auth
+        connection_socket.send(SOCKSv5_HEADER + Socksv5.NO_AUTH)
+
+        # receive destination address
+        version = connection_socket.recv(1)
+        if version != SOCKSv5_HEADER:
+            raise ParserException("Not a SOCKSv5 request")
+
+        mode = connection_socket.recv(1)
+        if mode == Socksv5.BIND_MODE:
+            raise ParserException("BIND mode not supported")
+        if mode == Socksv5.UDP_PORT:
+            raise ParserException("UDP mode not supported")
+        if mode != Socksv5.REQUEST_MODE:
+            raise ParserException(f"Socks mode {mode} not supported")
+
+        if connection_socket.recv(1) != Socksv5.RESERVED_BYTE:
+            raise ParserException("Invalid reserved byte")
+
+        host = Socksv5._read_address(connection_socket)
+
+        port = int.from_bytes(connection_socket.read(2), byteorder="big")
+        if not 0 <= port <= 65535:
+            raise ParserException(f"Invalid port {port}")
+
+        return host, port
+
+    @staticmethod
+    def _read_address(connection_socket: WrappedTcpSocket) -> str:
+        address_type = connection_socket.recv(1)
+        if address_type == b"\x01":
+            # ipv4
+            host = ".".join(f"{c}" for c in connection_socket.read(4))
+        elif address_type == b"\x04":
+            # ipv6
+            host = ":".join(f"{c}" for c in connection_socket.read(16))
+        elif address_type == b"\x03":
+            # domain
+            length = int.from_bytes(connection_socket.read(1), byteorder="big")
+            host = connection_socket.read(length).decode("utf-8")
+        else:
+            raise ParserException(f"Address type {address_type} not supported")
+        return host
+
+    @staticmethod
+    def socks5_auth_methods() -> bytes:
+        return SOCKSv5_HEADER + b"\x01" + Socksv5.NO_AUTH
+
+    @staticmethod
+    def socks5_request(server_address: NetworkAddress):
+        if not is_valid_ipv4_address(server_address.host):
+            domain = server_address.host.encode("utf-8")
+            address = b"\x03" + len(domain).to_bytes() + domain
+        else:
+            address = b"\x01" + socket.inet_aton(server_address.host)
+        return (
+            SOCKSv5_HEADER
+            + b"\x01"
+            + Socksv5.RESERVED_BYTE
+            + address
+            + server_address.port.to_bytes(2, byteorder="big")
+        )
+
+    @staticmethod
+    def socks5_ok(connection_socket: WrappedTcpSocket) -> bytes:
+        host_ip, host_port = connection_socket.socket.getsockname()
+        host_address = b"\x01" + socket.inet_aton(host_ip)
+        return SOCKSv5_HEADER + b"\x00" + Socksv5.RESERVED_BYTE + host_address + host_port.to_bytes(2, byteorder="big")

network/protocols/Tls.py

@@ -0,0 +1,113 @@
+from time import time
+
+from exception.ParserException import ParserException
+from network.tcp.WrappedTcpSocket import WrappedTcpSocket
+from util.constants import TLS_1_0_HEADER, TLS_1_1_HEADER, TLS_1_2_HEADER
+
+
+class Tls:
+    @staticmethod
+    def read_sni(wrapped_socket: WrappedTcpSocket, timeout: int) -> str:
+        """
+        Attempts to read the host from the SNI extension. If the client does not send a SNI extension, None is returned.
+        :return: host of the sni extension
+        """
+
+        try:
+            tls_message = Tls._read_tls_message(wrapped_socket, peek=True, timeout=timeout)
+        except ParserException as e:
+            raise e
+        except Exception as e:
+            raise ParserException(e)
+
+        # check if record is a client hello
+        if tls_message[0] != 0x01:
+            raise ParserException("Not a client hello")
+
+        # skip everything until SNI extension
+        p = 38
+        # session_id
+        p += 1 + int.from_bytes(tls_message[p : p + 1], byteorder="big")
+        # cipher suites
+        p += 2 + int.from_bytes(tls_message[p : p + 2], byteorder="big")
+        # compression methods
+        p += 1 + int.from_bytes(tls_message[p : p + 1], byteorder="big")
+
+        if p >= len(tls_message):
+            raise ParserException("No extensions present")
+
+        # extensions
+        p += 2
+
+        while p < len(tls_message):
+            ext_type = int.from_bytes(tls_message[p : p + 2], byteorder="big")
+            p += 2
+            ext_length = int.from_bytes(tls_message[p : p + 2], byteorder="big")
+            p += 2
+
+            if ext_type != 0:
+                # skip over not sni
+                p += ext_length
+            else:
+                # sni
+                list_len = int.from_bytes(tls_message[p : p + 2], byteorder="big")
+                p += 2
+                _list_len = p + list_len
+                while p < _list_len:
+                    name_type = int.from_bytes(tls_message[p : p + 1], byteorder="big")
+                    p += 1
+                    name_len = int.from_bytes(tls_message[p : p + 2], byteorder="big")
+                    p += 2
+                    if name_type != 0:
+                        # unknown name type, skip
+                        p += name_len
+                    else:
+                        # hostname
+                        hostname = tls_message[p : p + name_len]
+                        return hostname.decode("ASCII")
+        raise ParserException("No SNI present")
+
+    @staticmethod
+    def _read_tls_message(wrapped_socket: WrappedTcpSocket, timeout: int, peek=False) -> bytes:
+        """
+        Reads the content of the next tls message from the socket.
+        :param: whether to peek the tls message.
+        :return: The content of the TLS message
+        """
+        message = b""
+        buffer = b""
+        # headers
+        len_to_read = 4
+        # prevent infinite sockets
+        timestamp = time()
+        # parse records until message complete
+        while len(message) < len_to_read and int(time() - timestamp) < timeout:
+            record = Tls._read_tls_record(wrapped_socket)
+            buffer += record
+            message += record[5:]
+            if len(message) >= 4:
+                # can parse message length
+                len_to_read = int.from_bytes(message[1:4], byteorder="big")
+        if peek:
+            # re-inject all read records
+            wrapped_socket.inject(buffer)
+        return message
+
+    @staticmethod
+    def _read_tls_record(
+        wrapped_socket: WrappedTcpSocket,
+    ) -> bytes:
+        """
+        Reads the content of the next tls record from the wire with headers. Throws exception if no record is received.
+        :return: The contents of the TLS record
+        """
+        # read record header
+        data = wrapped_socket.read(5)
+
+        # check if first 3 bytes are a tls header
+        if data[:3] != TLS_1_0_HEADER and data[:3] != TLS_1_1_HEADER and data[:3] != TLS_1_2_HEADER:
+            raise ParserException("Not a TLS connection")
+
+        # read record length
+        record_length = int.from_bytes(data[3:5], byteorder="big")
+        return data + wrapped_socket.read(record_length)

network/tcp/Forwarder.py

@@ -0,0 +1,203 @@
+import logging
+import threading
+
+from enumerators.TlsVersion import TlsVersion
+from modules.http.HttpStrategies import HttpStrategies
+from network.protocols.Http import Http
+from network.tcp.WrappedTcpSocket import WrappedTcpSocket
+from util.constants import STANDARD_SOCKET_RECEIVE_SIZE, TLS_1_0_HEADER, TLS_1_1_HEADER, TLS_1_2_HEADER
+
+
+class Forwarder:
+    def __init__(
+        self,
+        socket1: WrappedTcpSocket,
+        socket1_name: str,
+        socket2: WrappedTcpSocket,
+        socket2_name: str,
+        record_frag: bool = False,
+        record_version: str = TlsVersion.DEFAULT.value,
+        frag_size: int = 0,
+        http_strategy=None,
+        http_smuggling_uncensored_url: str = "",
+    ):
+        self.socket1 = socket1
+        self.socket2 = socket2
+        self.socket1_name = socket1_name
+        self.socket2_name = socket2_name
+        self.record_frag = record_frag
+        self.record_version = record_version
+        self.frag_size = frag_size
+        self.http_strategy = http_strategy
+        self.http_smuggling_uncensored_url = http_smuggling_uncensored_url
+
+    def start(self):
+        # start sending thread
+        threading.Thread(
+            target=self._forward,
+            args=(
+                self.socket1,
+                self.socket2,
+                f"{self.socket1_name}->{self.socket2_name}",
+                self.record_frag,
+                self.record_version,
+                self.http_strategy,
+            ),
+        ).start()
+        # start receiving thread
+        threading.Thread(
+            target=self._forward,
+            args=(
+                self.socket2,
+                self.socket1,
+                f"{self.socket2_name}->{self.socket1_name}",
+            ),
+        ).start()
+
+    def _forward(
+        self,
+        from_socket: WrappedTcpSocket,
+        to_socket: WrappedTcpSocket,
+        direction: str,
+        record_frag=False,
+        record_version: str = TlsVersion.DEFAULT.value,
+        http_strategy=None,
+    ):
+        """
+        Forwards data between two sockets with optional record manipulation. Falls back to forwarding if no TLS records
+        can be parsed from the connection anymore.
+        :param to_socket: Socket to receive data from.
+        :param from_socket: Socket to forward data to.
+        :param record_frag: Whether to fragment handshake records
+        :return: None
+        """
+        alter_tls = record_frag or (record_version != TlsVersion.DEFAULT.value)
+        try:
+            while True:
+                # if record frag is configured, it takes precedence over http manipulations
+                if alter_tls:
+                    # fragment TLS
+                    if not self.attempt_tls_fragmentation(
+                        from_socket, to_socket, direction, record_frag, record_version
+                    ):
+                        # turn of record frag and force normal forwarding
+                        alter_tls = False
+                        continue
+
+                elif http_strategy is not None:
+                    if not self.attempt_http_manipulations(from_socket, to_socket, direction, http_strategy):
+                        # turn of htt manipulations and force normal forwarding
+                        http_strategy = None
+                        continue
+                else:
+                    # normal forwarding
+                    data = from_socket.recv(STANDARD_SOCKET_RECEIVE_SIZE)
+                    if not data:
+                        self.debug("Connection closed, closing both sockets", direction)
+                        to_socket.try_close()
+                        break
+                    else:
+                        to_socket.send(data)
+            logging.info("### Cancelled forwarding ###")
+        except BrokenPipeError as e:
+            self.debug(f"Forwarding broken with {e}", direction)
+            to_socket.try_close()
+        except OSError as e:
+            if e.errno == 9:
+                # Bad file descriptor, socket closed by other forwarding queue
+                to_socket.try_close()
+            else:
+                self.debug(f"OSError while forwarding, closing sockets: {e}", direction)
+                to_socket.try_close()
+        except Exception as e:
+            self.debug(f"Exception while forwarding: {e}", direction)
+            to_socket.try_close()
+        self.info(f"{direction}: Closed connection", direction)
+
+    def attempt_http_manipulations(
+        self, from_socket: WrappedTcpSocket, to_socket: WrappedTcpSocket, direction: str, http_strategy
+    ) -> bool:
+        """
+        Attempts to parse HTTP requests and apply manipulations if an HTTP strategy is set. Sends the data.
+
+        Returns: True on successful parsing, false otherwise
+        """
+
+        if not Http.is_valid_http(from_socket):
+            self.debug(
+                "Received non-HTTP data, turning off HTTP manipulations for this and following requests", direction
+            )
+            return False
+        # we allow 4k bytes max
+        data = from_socket.recv(STANDARD_SOCKET_RECEIVE_SIZE)
+        self.debug("Received HTTP data and manipulating request", direction)
+        data = HttpStrategies.manipulations(
+            data, strategy=http_strategy, http_smuggling_uncensored_url=self.http_smuggling_uncensored_url
+        )
+        self.debug(f"After applying Manipulation: {data}", direction)
+        to_socket.send(data)
+        return True
+
+    def attempt_tls_fragmentation(
+        self, from_socket: WrappedTcpSocket, to_socket: WrappedTcpSocket, direction: str, record_frag, record_version
+    ) -> bool:
+        """
+        Attempts to parse and fragment TLS handshake records. Sends data if fragmentable, does not if otherwise.
+
+        Returns: True on successful parsing, false otherwise
+        """
+        try:
+            record_header = from_socket.peek(5)
+        except Exception:
+            self.debug("Could not read record_header bytes. Disabling record fragmentation", direction)
+            return False
+        base_header = record_header[:3]
+        record_len = int.from_bytes(record_header[3:], byteorder="big")
+        is_tls = base_header == TLS_1_0_HEADER or base_header == TLS_1_1_HEADER or base_header == TLS_1_2_HEADER
+        if not is_tls:
+            self.debug(
+                f"Received first non-handshake TLS record header: {record_header}. Turning off "
+                f"TLS record fragmentation for this and following records",
+                direction,
+            )
+            # did not receive tls record
+            return False
+        else:
+            self.debug("Received TLS handshake record - fragmenting", direction)
+        try:
+            record = from_socket.read(5 + record_len)
+        except Exception:
+            self.debug(f"Could not read {record_len} record bytes. Disabling record fragmentation", direction)
+            return False
+        if record_version != TlsVersion.DEFAULT.value:
+            record_version_bytes = bytes.fromhex(record_version)
+            record = self.replace_version_in_record_header(record, record_version_bytes)
+            base_header = base_header[:1] + record_version_bytes
+        if record_frag:
+            record = self.fragment_record(base_header, record_len, record[5:])
+        to_socket.send(record)
+        return True
+
+    def fragment_record(self, record_base_header: bytes, record_length: int, record_body: bytes) -> bytes:
+        fragments = [record_body[i : i + self.frag_size] for i in range(0, record_length, self.frag_size)]
+        fragmented_message = b""
+        for fragment in fragments:
+            # construct header
+            fragmented_message += record_base_header + int.to_bytes(len(fragment), byteorder="big", length=2)
+            fragmented_message += fragment
+        return fragmented_message
+
+    def replace_version_in_record_header(self, record: bytes, version: bytes) -> bytes:
+        header_to_keep = record[:1]
+        record_length_and_body = record[3:]
+        return header_to_keep + version + record_length_and_body
+
+    # LOGGER utility functions
+    def _logger_string(self, message: str, prefix: str) -> str:
+        return f"{prefix}: {message}"
+
+    def debug(self, message: str, prefix: str):
+        logging.debug(self._logger_string(message, prefix))
+
+    def info(self, message: str, prefix: str):
+        logging.info(self._logger_string(message, prefix))