Multi_Script/Proxy3.py

# -*- coding: utf-8 -*-

# ==============================================================================
# SCRIPT DE PROXY MULTIFILAMENTADO CON RESPUESTAS ROTATIVAS
#
# - Basado en la versión robusta y estable.
# - Añade rotación dinámica del mensaje de estado en la respuesta HTTP 101.
# - Utiliza un iterador cíclico para cambiar el mensaje en cada nueva conexión.
#
# Creado por Gemini
# ==============================================================================
#screen -dmS badvpn2 /bin/badvpn-udpgw --listen-addr 127.0.0.1:7300 --max-clients 1000 --max-connections-for-client 100
#screen -dmS pydic-80 python3 /etc/VPS-MX/protocolo/Pythonv1.py 8080
import socket
import threading
import select
import sys
import time
import os
import logging
import logging.handlers
import itertools  # 💡 Importado para la rotación de mensajes

# ==============================================================================
# CONFIGURACIÓN GLOBAL Y SETUP DE LOGGING
# ==============================================================================
IPV4_ADDR = '0.0.0.0'
IPV6_ADDR = '::'

if sys.argv[1:]:
    LISTENING_PORT = int(sys.argv[1])
else:
    LISTENING_PORT = 8080

PASS = ''
PRIORITIZE_IPV4 = True
CONNECTION_COOLDOWN_TIME = 10
MAX_CONNECTIONS = 1000 

# Constantes de red
BUFLEN = 4096 * 4
TIMEOUT = 60
DEFAULT_HOST = '127.0.0.1:223'

# 💡 LISTA DE MENSAJES PARA ROTAR
# Puedes añadir todos los que quieras aquí.
MENSAJES_ROTATIVOS = [
    "Pfsense",
    "OPNsense",
    "VyOS",
    "TNSR"
]

# Creamos un iterador infinito que rota sobre la lista anterior
mensaje_iterator = itertools.cycle(MENSAJES_ROTATIVOS)
# Lock para asegurar que la extracción del siguiente mensaje sea segura entre hilos
iterator_lock = threading.Lock()

# Configuración del log
LOG_FILE = '/root/proxy.log'
MAX_LOG_SIZE = 5 * 1024 * 1024 
BACKUP_COUNT = 5 

def setup_logging():
    log_format = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler = logging.handlers.RotatingFileHandler(LOG_FILE, maxBytes=MAX_LOG_SIZE, backupCount=BACKUP_COUNT)
    file_handler.setFormatter(log_format)
    console_handler = logging.StreamHandler()
    console_handler.setFormatter(log_format)
    logger = logging.getLogger()
    logger.setLevel(logging.INFO)
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    return logger

logger = setup_logging()

last_connection_times = {}
last_connection_lock = threading.Lock()
connection_limit_semaphore = threading.Semaphore(MAX_CONNECTIONS)

# ==============================================================================
# CLASE DEL SERVIDOR
# ==============================================================================
class Server(threading.Thread):
    def __init__(self, port):
        super().__init__()
        self.running = False
        self.port = port
        self.threads = []
        self.threads_lock = threading.Lock()
        self.ipv4_socket = None
        self.ipv6_socket = None

    def run(self):
        logger.info("\n:-------PythonProxy-------:\n")
        logger.info(f"Listening port: {self.port}")
        logger.info(f"Mensajes configurados: {len(MENSAJES_ROTATIVOS)}\n")
        logger.info(":-------------------------:\n")

        try:
            self.ipv4_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.ipv4_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.ipv4_socket.bind((IPV4_ADDR, self.port))
            self.ipv4_socket.listen(0)
        except socket.error as e:
            logger.error(f"Error IPv4: {e}")
            self.ipv4_socket = None

        try:
            self.ipv6_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
            self.ipv6_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.ipv6_socket.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
            self.ipv6_socket.bind((IPV6_ADDR, self.port, 0, 0))
            self.ipv6_socket.listen(0)
        except socket.error as e:
            logger.error(f"Error IPv6: {e}")
            self.ipv6_socket = None

        if not self.ipv4_socket and not self.ipv6_socket:
            return

        self.running = True
        active_sockets = [s for s in [self.ipv4_socket, self.ipv6_socket] if s]

        try:
            while self.running:
                readable, _, _ = select.select(active_sockets, [], [], 2)
                for sock in readable:
                    c, addr = sock.accept()
                    client_ip = addr[0]
                    current_time = time.time()

                    with last_connection_lock:
                        last_time = last_connection_times.get(client_ip, 0)
                        if current_time - last_time < CONNECTION_COOLDOWN_TIME:
                            c.close()
                            continue
                        last_connection_times[client_ip] = current_time

                    if not connection_limit_semaphore.acquire(timeout=0):
                            c.close()
                            continue

                    c.setblocking(1)
                    conn = ConnectionHandler(c, self, addr)
                    conn.start()
                    self.add_conn(conn)
        except Exception as e:
            logger.error(f"Error servidor: {e}")
        finally:
            self.running = False

    def add_conn(self, conn):
        with self.threads_lock:
            if self.running: self.threads.append(conn)

    def remove_conn(self, conn):
        with self.threads_lock:
            if conn in self.threads: self.threads.remove(conn)

    def close(self):
        self.running = False
        with self.threads_lock:
            for c in list(self.threads): c.close()

# ==============================================================================
# CLASE MANEJADORA DE CONEXIONES
# ==============================================================================
class ConnectionHandler(threading.Thread):
    def __init__(self, client_socket, server, addr):
        super().__init__()
        self.client = client_socket
        self.server = server
        self.addr = addr
        self.log_prefix = f"{addr[0]}:{addr[1]}"
        self.target = None
        self.client_closed = False
        self.target_closed = True

    def close(self):
        try:
            if not self.client_closed:
                self.client.close()
        except: pass
        finally: self.client_closed = True

        try:
            if not self.target_closed:
                self.target.close()
        except: pass
        finally: self.target_closed = True
        
        connection_limit_semaphore.release()

    def run(self):
        try:
            data = self.client.recv(BUFLEN)
            if not data: return
            headers = data.decode('latin-1')
            host_port = self.find_header(headers, 'X-Real-Host') or DEFAULT_HOST

            # 💡 Lógica de rotación: obtenemos el siguiente mensaje de la lista
            with iterator_lock:
                mensaje_actual = next(mensaje_iterator)
            
            # Construimos la respuesta HTTP dinámica
            response_dinamica = f"HTTP/1.1 101 {mensaje_actual}\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n".encode()

            logger.info(f"[{self.log_prefix}] Usando mensaje: '{mensaje_actual}'")
            
            self.connect_target(host_port)
            self.client.sendall(response_dinamica)
            self.do_tunnel()

        except Exception as e:
            logger.error(f"Error en {self.log_prefix}: {e}")
        finally:
            self.close()
            self.server.remove_conn(self)

    def find_header(self, head, header):
        aux = head.find(header + ': ')
        if aux == -1: return ''
        head = head[aux + len(header) + 2:]
        aux = head.find('\r\n')
        return head[:aux]

    def connect_target(self, host_port):
        i = host_port.find(':')
        host = host_port[:i] if i != -1 else host_port
        port = int(host_port[i+1:]) if i != -1 else 22
        
        addr_info = socket.getaddrinfo(host, port, socket.AF_UNSPEC, socket.SOCK_STREAM)
        for res in addr_info:
            af, socktype, proto, _, sa = res
            try:
                self.target = socket.socket(af, socktype, proto)
                self.target.connect(sa)
                self.target_closed = False
                return
            except:
                if self.target: self.target.close()
        raise RuntimeError("No se pudo conectar al destino")

    def do_tunnel(self):
        socs = [self.client, self.target]
        while True:
            readable, _, _ = select.select(socs, [], [], TIMEOUT)
            if not readable: break
            for sock in readable:
                data = sock.recv(BUFLEN)
                if not data: return
                if sock is self.target:
                    self.client.send(data)
                else:
                    self.target.sendall(data)

def main():
    server = Server(LISTENING_PORT)
    server.start()
    try:
        while True: time.sleep(2)
    except KeyboardInterrupt:
        server.close()

if __name__ == '__main__':
    main()