membuat tunelling dengan python untuk bypass limiter ISP

import socket
import ssl
import threading

def start_proxy_tunnel(local_port=8080, target_host='your-server.com', target_port=443):
    """Simple HTTP/HTTPS proxy tunnel"""
    
    def handle_client(client_socket):
        try:
            # Terima request dari client
            request = client_socket.recv(4096)
            
            # Buat koneksi ke server target
            remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            
            # Untuk HTTPS, gunakan SSL
            if target_port == 443:
                context = ssl.create_default_context()
                remote_socket = context.wrap_socket(
                    remote_socket, 
                    server_hostname=target_host
                )
            
            remote_socket.connect((target_host, target_port))
            
            # Kirim request ke server
            remote_socket.send(request)
            
            # Relay data bolak-balik
            while True:
                remote_data = remote_socket.recv(4096)
                if len(remote_data) == 0:
                    break
                client_socket.send(remote_data)
                
        except Exception as e:
            print(f"Error: {e}")
        finally:
            client_socket.close()
            remote_socket.close()
    
    # Start proxy server
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(('0.0.0.0', local_port))
    server.listen(5)
    
    print(f"[*] Proxy tunnel berjalan di port {local_port}")
    
    while True:
        client_socket, addr = server.accept()
        print(f"[*] Koneksi dari {addr[0]}:{addr[1]}")
        client_handler = threading.Thread(target=handle_client, args=(client_socket,))
        client_handler.start()

import socket
import struct
import select

class Socks5Proxy:
    def __init__(self, listen_port=1080, target_host='your-server.com', target_port=8888):
        self.listen_port = listen_port
        self.target_host = target_host
        self.target_port = target_port
        
    def handle_handshake(self, client_socket):
        # Terima version dan methods
        version = client_socket.recv(1)
        nmethods = client_socket.recv(1)
        methods = client_socket.recv(ord(nmethods))
        
        # Kirim response (no auth required)
        client_socket.send(b'\x05\x00')
        
        # Terima request
        version = client_socket.recv(1)
        cmd = client_socket.recv(1)
        rsv = client_socket.recv(1)
        atype = client_socket.recv(1)
        
        if atype == b'\x01':  # IPv4
            addr = socket.inet_ntoa(client_socket.recv(4))
        elif atype == b'\x03':  # Domain name
            domain_length = ord(client_socket.recv(1))
            addr = client_socket.recv(domain_length)
        else:
            return None
            
        port = struct.unpack('!H', client_socket.recv(2))[0]
        
        return addr, port
    
    def start(self):
        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server.bind(('0.0.0.0', self.listen_port))
        server.listen(5)
        
        print(f"[*] SOCKS5 proxy berjalan di port {self.listen_port}")
        
        while True:
            client_socket, addr = server.accept()
            print(f"[*] Koneksi dari {addr}")
            
            try:
                # Handle SOCKS5 handshake
                dest_info = self.handle_handshake(client_socket)
                if not dest_info:
                    continue
                    
                dest_addr, dest_port = dest_info
                
                # Kirim success response
                client_socket.send(b'\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00')
                
                # Buat koneksi ke target
                remote_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                remote_socket.connect((self.target_host, self.target_port))
                
                # Relay data
                self.relay_traffic(client_socket, remote_socket)
                
            except Exception as e:
                print(f"Error: {e}")
                client_socket.close()
    
    def relay_traffic(self, client_socket, remote_socket):
        sockets = [client_socket, remote_socket]
        
        while True:
            readable, _, _ = select.select(sockets, [], [])
            
            for sock in readable:
                try:
                    data = sock.recv(4096)
                    if not data:
                        return
                        
                    if sock is client_socket:
                        remote_socket.send(data)
                    else:
                        client_socket.send(data)
                except:
                    return

import asyncio
import websockets
import socket
import threading

class WebSocketTunnel:
    def __init__(self, ws_server='wss://your-server.com/ws', local_port=8081):
        self.ws_server = ws_server
        self.local_port = local_port
        
    async def handle_tcp_over_ws(self, websocket, client_socket):
        """Handle bidirectional data transfer"""
        async def forward_to_ws():
            try:
                while True:
                    data = await asyncio.get_event_loop().run_in_executor(
                        None, client_socket.recv, 4096
                    )
                    if not data:
                        break
                    await websocket.send(data)
            except:
                pass
        
        async def forward_to_tcp():
            try:
                async for message in websocket:
                    client_socket.send(message)
            except:
                pass
        
        await asyncio.gather(
            forward_to_ws(),
            forward_to_tcp()
        )
        
    async def start_client(self):
        """Connect to WebSocket server and tunnel traffic"""
        async with websockets.connect(self.ws_server) as websocket:
            # Create local TCP server
            client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            client_socket.connect(('127.0.0.1', self.local_port))
            
            await self.handle_tcp_over_ws(websocket, client_socket)
            
            client_socket.close()
    
    def run(self):
        asyncio.run(self.start_client())

from cryptography.fernet import Fernet
import base64
import hashlib

class EncryptedTunnel:
    def __init__(self, password):
        self.key = self.generate_key(password)
        self.cipher = Fernet(self.key)
    
    def generate_key(self, password):
        """Generate key dari password"""
        key = hashlib.sha256(password.encode()).digest()
        return base64.urlsafe_b64encode(key)
    
    def encrypt_data(self, data):
        """Encrypt data sebelum dikirim"""
        return self.cipher.encrypt(data)
    
    def decrypt_data(self, encrypted_data):
        """Decrypt data yang diterima"""
        return self.cipher.decrypt(encrypted_data)

# server.py
from proxy_tunnel import start_proxy_tunnel
start_proxy_tunnel(local_port=8888, target_host='target-website.com', target_port=80)

# client.py
import requests

proxies = {
    'http': 'http://your-server.com:8888',
    'https': 'http://your-server.com:8888'
}

response = requests.get('https://target-website.com', proxies=proxies)
print(response.text)