#!/usr/bin/env python3
"""
Mini serveur SOCKS5 avec authentification — pour Termux (Android).
Aucune dependance : stdlib uniquement.
Usage:  python socks5.py
"""
import asyncio, struct, sys

# ---- CHANGE CES DEUX VALEURS ----
USER = "mimsou"
PASS = "c89a5cbb79c032359490ed36e3f5972c"
PORT = 1080
# ---------------------------------

async def pipe(reader, writer):
    try:
        while True:
            data = await reader.read(8192)
            if not data:
                break
            writer.write(data)
            await writer.drain()
    except Exception:
        pass
    finally:
        try:
            writer.close()
        except Exception:
            pass

async def handle(reader, writer):
    try:
        # 1. negation de methode
        ver, n = await reader.readexactly(2)
        methods = await reader.readexactly(n)
        if 0x02 not in methods:
            writer.write(b"\x05\xff")
            await writer.drain()
            return
        writer.write(b"\x05\x02")
        await writer.drain()

        # 2. authentification user/pass
        _, ulen = await reader.readexactly(2)
        user = (await reader.readexactly(ulen)).decode(errors="replace")
        plen = (await reader.readexactly(1))[0]
        pwd = (await reader.readexactly(plen)).decode(errors="replace")
        if user != USER or pwd != PASS:
            writer.write(b"\x01\x01")
            await writer.drain()
            return
        writer.write(b"\x01\x00")
        await writer.drain()

        # 3. requete de connexion
        _, cmd, _, atyp = await reader.readexactly(4)
        if atyp == 1:
            host = ".".join(str(b) for b in await reader.readexactly(4))
        elif atyp == 3:
            ln = (await reader.readexactly(1))[0]
            host = (await reader.readexactly(ln)).decode(errors="replace")
        elif atyp == 4:
            raw = await reader.readexactly(16)
            host = ":".join(f"{(raw[i]<<8)+raw[i+1]:x}" for i in range(0, 16, 2))
        else:
            return
        port = struct.unpack("!H", await reader.readexactly(2))[0]

        if cmd != 0x01:  # seul CONNECT est supporte
            writer.write(b"\x05\x07\x00\x01" + b"\x00" * 6)
            await writer.drain()
            return

        # 4. connexion vers la destination
        remote_r, remote_w = await asyncio.open_connection(host, port)
        writer.write(b"\x05\x00\x00\x01" + b"\x00" * 6)
        await writer.drain()

        # 5. relais bidirectionnel
        await asyncio.gather(pipe(reader, remote_w), pipe(remote_r, writer))
    except Exception:
        pass
    finally:
        try:
            writer.close()
        except Exception:
            pass

async def main():
    server = await asyncio.start_server(handle, "127.0.0.1", PORT)
    print(f"SOCKS5 actif sur 127.0.0.1:{PORT}")
    print("(laisser cette fenetre ouverte — Ctrl+C pour arreter)")
    async with server:
        await server.serve_forever()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\nArrete.")
