Redirect an OpenVpn connection through a python socket

Basically, for me to be able to connect to the server, I need it to respond with a very specific http header.

header = ‘HTTP/1.1 200 OKrnConnection: Startrnrn’

So I want to first create a socket connection then wait for the server to pass the header then the connection will be stabilized.

After that I want to use the socket as a proxy for the OpenVpn cli.
In such a way that I redirect,

OpenVpn Cli <-> Socket(Local) <-> Socket(Server) <-> OpenVpnServer(Port 1194)

So far I haven’t been able to find out if this is possible or if there is an easier way * Keeping the custom header

Here is my client/server code

Server

import socket
import threading
import time

def handle_client(client_socket, addr):
    try:
        print(f"Conexão recebida de {addr}")

        header = 'HTTP/1.1 200 OKrnConnection: Startrnrn'
        client_socket.sendall(header.encode())
        redirect_message = 'Redirecionando para OpenVPN'
        client_socket.sendall(redirect_message.encode())

        # Redirecionar a conexão para o servidor OpenVPN
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as vpn_socket:
            vpn_socket.connect(('server_ip', 1194))  # IP e porta do servidor OpenVPN

            # Encaminhamento de socket
            while True:
                # Receber dados do cliente e enviar para o OpenVPN
                client_data = client_socket.recv(1024)
                if not client_data:
                    break
                vpn_socket.sendall(client_data)

                # Receber dados do OpenVPN e enviar para o cliente
                vpn_data = vpn_socket.recv(1024)
                if not vpn_data:
                    break
                client_socket.sendall(vpn_data)
    finally:
        client_socket.close()
        print(f"Conexão com {addr} encerrada")

def main():
    # Criar o socket do servidor
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(('0.0.0.0', 80))
    server_socket.listen(5)
    print("Servidor escutando na porta 80")

    try:
        while True:
            client_socket, addr = server_socket.accept()
            client_thread = threading.Thread(target=handle_client, args=(client_socket, addr))
            client_thread.start()
    finally:
        server_socket.close()

if __name__ == "__main__":
    main()

Client

import socket
import threading

def handle_vpn_connection(server_socket):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as vpn_client_socket:
        vpn_client_socket.bind(('0.0.0.0', 8080))
        vpn_client_socket.listen(1)
        print("Aguardando conexão do cliente OpenVPN na porta 8080...")
        
        client_conn, client_addr = vpn_client_socket.accept()
        print(f"Conexão OpenVPN estabelecida de {client_addr}")

        try:
            # Encaminhamento de dados
            while True:
                # Receber dados do cliente OpenVPN e enviar para o servidor
                vpn_data = client_conn.recv(1024)
                if not vpn_data:
                    break
                server_socket.sendall(vpn_data)

                # Receber dados do servidor e enviar para o cliente OpenVPN
                server_data = server_socket.recv(1024)
                if not server_data:
                    break
                client_conn.sendall(server_data)
        finally:
            print(vpn_data)
            print(server_data)

            print("Encerrando a conexão OpenVPN")
            client_conn.close()

def main():
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server_socket:
            # Conectar ao servidor na porta 80
            server_socket.connect(('server_ip', 80))
            print("Conectado ao servidor")

            # Enviar um pedido GET
            get_request = "ACL / HTTP/1.1"
            server_socket.sendall(get_request.encode())

            # Receber e validar o cabeçalho personalizado
            response_header = server_socket.recv(1024).decode()
            print("Header recebido:", response_header)

            expected_header = 'HTTP/1.1 200 OKrnConnection: Startrnrn'
            if response_header.startswith(expected_header):
                print("Cabeçalho personalizado confirmado")
            else:
                print("Cabeçalho personalizado não corresponde ao esperado")

            # Receber a mensagem de redirecionamento
            redirect_message = server_socket.recv(1024).decode()
            print("Mensagem recebida:", redirect_message)

            # Iniciar a escuta para conexões OpenVPN
            thread = threading.Thread(target=handle_vpn_connection, args=(server_socket,))
            thread.start()
            thread.join()

    except Exception as e:
        print(f"Ocorreu um erro: {e}")

if __name__ == "__main__":
    main()

The output CLIENT I have is;

Cabeçalho personalizado confirmado
Mensagem recebida: Redirecionando para OpenVPN
Aguardando conexão do cliente OpenVPN na porta 8080...
Conexão OpenVPN estabelecida de ('127.0.0.1', 34990)
b'CONNECT ip_server:80 HTTP/1.0rnHost: 54.207.79.17rnrn'
b''
Encerrando a conexão OpenVPN