Skip to content

Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic

11.4 KB
Raw Blame
#!/usr/bin/env python3
"""Misbehaving upstream proxies for ProxyBridge's fault tests (never use these for anything else).

usage: fault_proxies.py <logfile>      listens on 127.0.0.1; the behaviour is chosen by the port that is asked for.

SOCKS5 19100 - by the requested destination port:
  9001-9008 reply code 1-8                 9010 BND is a domain name       9011 BND is IPv6          9012 BND of unknown type
  9013 close after the request             9014 never answers (stall)      9015 SOCKS4-style reply   9016 data, then close
  9017 sends 4 MiB of a known pattern      9018 echo server                9019 close right after the greeting
SOCKS5 greeting variants: 19101 method 0x01 (GSSAPI)  19102 no acceptable method  19103 asks for a login and rejects every one
                          19104 asks for a login (clients without credentials)    19105 accepts any login, then works as 19100
                          19106 works for CONNECT but refuses UDP ASSOCIATE
HTTP CONNECT 19110 - by the requested destination port:
  9021 403   9022 407   9023 502   9024 503   9025 301   9026 200 plus early data   9027 not HTTP   9028 close, no reply
  9029 stall   9030 200 then close   9031 headers in two segments   9032 oversized header block
SOCKS5 UDP ASSOCIATE 19120-19127 (control ports, each relays echoes "UDP-U <dst> <payload>"):
  19120 BND.ADDR 0.0.0.0   19121 BND is a domain   19122 BND is ::1   19123 SPOOF* replies come from a stranger
  19124 malformed replies by payload prefix (FRAG, DOM, SHORT, ZERO, OK)   19125 refuses the association
  19126 closes the control connection after the first datagram   19127 swallows datagrams
"""
import asyncio, socket, struct, sys

LOG = open(sys.argv[1], "a", buffering=1)
PATTERN = bytes((i * 7 + 3) & 0xFF for i in range(65536))
PATTERN_TOTAL = 4 << 20


def log(*a):
    LOG.write(" ".join(str(x) for x in a) + "\n")


async def read_addr(reader):
    atyp = (await reader.readexactly(1))[0]
    if atyp == 1:
        raw = await reader.readexactly(4)
    elif atyp == 4:
        raw = await reader.readexactly(16)
    else:
        n = (await reader.readexactly(1))[0]
        raw = await reader.readexactly(n)
    return atyp, raw, struct.unpack("!H", await reader.readexactly(2))[0]


def reply(rep, atyp=1, addr=b"\0\0\0\0", port=0):
    if atyp == 3:
        return bytes([5, rep, 0, 3, len(addr)]) + addr + struct.pack("!H", port)
    return bytes([5, rep, 0, atyp]) + addr + struct.pack("!H", port)


async def serve_socks(reader, writer, greeting):
    try:
        ver, n = await reader.readexactly(2)
        methods = await reader.readexactly(n)
        if greeting == "gssapi":
            writer.write(b"\x05\x01"); await writer.drain(); return
        if greeting == "none":
            writer.write(b"\x05\xff"); await writer.drain(); return
        if greeting in ("reject", "login", "any"):
            writer.write(b"\x05\x02"); await writer.drain()
            v, ul = await reader.readexactly(2)
            await reader.readexactly(ul)
            pl = (await reader.readexactly(1))[0]
            await reader.readexactly(pl)
            ok = greeting == "any"
            writer.write(b"\x01" + (b"\x00" if ok else b"\x01")); await writer.drain()
            log("AUTH", greeting, "accepted" if ok else "rejected", "userlen", ul, "passlen", pl)
            if not ok:
                return
        else:
            writer.write(b"\x05\x00"); await writer.drain()
        try:
            _v, cmd, _r = await reader.readexactly(3)
        except asyncio.IncompleteReadError:
            return                                    # 9019: the client gave up or we are meant to close here
        atyp, raw, port = await read_addr(reader)
        log("TCP" if cmd == 1 else "CMD%d" % cmd, port, "atyp", atyp)
        if greeting == "noudp" and cmd != 1:
            writer.write(reply(7)); await writer.drain(); return
        if port == 9019:
            return
        if 9001 <= port <= 9008:
            writer.write(reply(port - 9000)); await writer.drain(); return
        if port == 9013:
            return
        if port == 9014:
            await asyncio.sleep(60); return
        if port == 9015:
            writer.write(b"\x04\x5a\0\0\0\0\0\0"); await writer.drain(); return
        if port == 9010:
            writer.write(reply(0, 3, b"bnd.example.test", 1080))
        elif port == 9011:
            writer.write(reply(0, 4, b"\0" * 15 + b"\x01", 1080))
        elif port == 9012:
            writer.write(b"\x05\x00\x00\x09junkjunk"); await writer.drain(); return
        else:
            writer.write(reply(0, 1, b"\x7f\0\0\x01", 0))
        await writer.drain()
        if port == 9016:
            writer.write(b"partial"); await writer.drain(); return
        if port == 9017:
            sent = 0
            while sent < PATTERN_TOTAL:
                writer.write(PATTERN); sent += len(PATTERN)
                await writer.drain()
            return
        if port == 9018:
            while True:
                d = await reader.read(65536)
                if not d:
                    return
                writer.write(d); await writer.drain()
        data = await reader.read(65536)
        writer.write(b"HTTP/1.0 200 OK\r\nContent-Length: 3\r\n\r\nok\n" if data.startswith(b"GET") else b"echo:" + data)
        await writer.drain()
    except Exception as e:
        log("ERR", repr(e))
    finally:
        writer.close()


async def serve_http(reader, writer):
    try:
        head = await reader.readuntil(b"\r\n\r\n")
        first = head.split(b"\r\n")[0].decode()
        port = int(first.split()[1].rsplit(":", 1)[1])
        log("HTTP", port)
        statuses = {9021: b"403 Forbidden", 9022: b"407 Proxy Authentication Required", 9023: b"502 Bad Gateway",
                    9024: b"503 Service Unavailable", 9025: b"301 Moved Permanently"}
        if port in statuses:
            writer.write(b"HTTP/1.1 " + statuses[port] + b"\r\nContent-Length: 4\r\n\r\nnope"); await writer.drain(); return
        if port == 9027:
            writer.write(b"NOTHTTP garbage\r\n\r\n"); await writer.drain(); return
        if port == 9028:
            return
        if port == 9029:
            await asyncio.sleep(60); return
        if port == 9030:
            writer.write(b"HTTP/1.1 200 OK\r\n\r\n"); await writer.drain(); return
        if port == 9031:
            writer.write(b"HTTP/1.1 200 Connection"); await writer.drain()
            await asyncio.sleep(0.3)
            writer.write(b" established\r\n\r\n"); await writer.drain()
        elif port == 9032:
            writer.write(b"HTTP/1.1 200 OK\r\n" + b"X-Pad: " + b"a" * 20000 + b"\r\n\r\n"); await writer.drain(); return
        elif port == 9026:
            writer.write(b"HTTP/1.1 200 OK\r\n\r\nEARLY-DATA"); await writer.drain()
        else:
            writer.write(b"HTTP/1.1 200 OK\r\n\r\n"); await writer.drain()
        data = await asyncio.wait_for(reader.read(65536), 5)
        writer.write(b"echo:" + data); await writer.drain()
    except Exception as e:
        log("ERR", repr(e))
    finally:
        writer.close()


class UdpRelay(asyncio.DatagramProtocol):
    def __init__(self, mode):
        self.mode = mode

    def connection_made(self, transport):
        self.t = transport
        self.stranger = None

    def datagram_received(self, data, addr):
        if len(data) < 10 or data[2] != 0:
            return
        atyp = data[3]
        if atyp == 1:
            raw, off = data[4:8], 8
        elif atyp == 4:
            raw, off = data[4:20], 20
        else:
            n = data[4]; raw, off = data[5:5 + n], 5 + n
        port = struct.unpack("!H", data[off:off + 2])[0]
        payload = data[off + 2:]
        if atyp == 1:
            dst = socket.inet_ntoa(raw) + ":" + str(port)
        elif atyp == 4:
            dst = socket.inet_ntop(socket.AF_INET6, raw) + ":" + str(port)
        else:
            dst = raw.decode() + ":" + str(port)
        log("UDP", self.mode, dst, len(payload))
        if self.mode == "swallow":
            return
        head = data[:off + 2]
        echo = f"UDP-U {dst} ".encode() + payload
        if self.mode == "spoof" and payload.startswith(b"SPOOF"):
            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
            s.bind(("127.0.0.1", 0)); s.sendto(head + echo, addr); s.close()
            return
        if self.mode == "malformed":
            if payload.startswith(b"FRAG"):
                self.t.sendto(b"\0\0\x01" + head[3:] + echo, addr); return
            if payload.startswith(b"DOM"):
                name = b"host.example"
                self.t.sendto(b"\0\0\0\x03" + bytes([len(name)]) + name + struct.pack("!H", port) + echo, addr); return
            if payload.startswith(b"SHORT"):
                self.t.sendto(b"\0\0\0", addr); return
            if payload.startswith(b"ZERO"):
                self.t.sendto(head, addr); return
        self.t.sendto(head + echo, addr)
        if self.mode == "dropctl":
            asyncio.get_running_loop().call_later(0.3, self.close_control)

    close_control = lambda self: None


def udp_control(mode, bind_ip="127.0.0.1"):
    async def handle(reader, writer):
        try:
            ver, n = await reader.readexactly(2)
            await reader.readexactly(n)
            writer.write(b"\x05\x00"); await writer.drain()
            _v, cmd, _r = await reader.readexactly(3)
            await read_addr(reader)
            if mode == "refuse" or cmd != 3:
                writer.write(reply(7)); await writer.drain(); return
            loop = asyncio.get_running_loop()
            relay_mode = {"dropctl": "dropctl", "spoof": "spoof", "malformed": "malformed", "swallow": "swallow"}.get(mode, "echo")
            fam = socket.AF_INET6 if mode == "ipv6" else socket.AF_INET
            sock = socket.socket(fam, socket.SOCK_DGRAM)
            sock.bind(("::1" if mode == "ipv6" else "127.0.0.1", 0))
            transport, proto = await loop.create_datagram_endpoint(lambda: UdpRelay(relay_mode), sock=sock)
            port = sock.getsockname()[1]
            if mode == "dropctl":
                proto.close_control = lambda: writer.close()
            if mode == "unspec":
                writer.write(reply(0, 1, b"\0\0\0\0", port))
            elif mode == "domain":
                writer.write(reply(0, 3, b"relay.example.test", port))
            elif mode == "ipv6":
                writer.write(reply(0, 4, b"\0" * 15 + b"\x01", port))
            else:
                writer.write(reply(0, 1, b"\x7f\0\0\x01", port))
            await writer.drain()
            log("ASSOC", mode)
            try:
                while await reader.read(1024):
                    pass
            finally:
                transport.close()
        except Exception as e:
            log("ERR", repr(e))
        finally:
            writer.close()
    return handle


async def main():
    def socks(greeting):
        return lambda r, w: serve_socks(r, w, greeting)
    for port, g in ((19100, "ok"), (19101, "gssapi"), (19102, "none"), (19103, "reject"), (19104, "login"), (19105, "any"), (19106, "noudp")):
        await asyncio.start_server(socks(g), "127.0.0.1", port)
    await asyncio.start_server(serve_http, "127.0.0.1", 19110)
    for port, mode in ((19120, "unspec"), (19121, "domain"), (19122, "ipv6"), (19123, "spoof"), (19124, "malformed"),
                       (19125, "refuse"), (19126, "dropctl"), (19127, "swallow")):
        await asyncio.start_server(udp_control(mode), "127.0.0.1", port)
    print("fault proxies up", flush=True)
    await asyncio.Event().wait()

asyncio.run(main())