from core.infrastructure.global_state import ProcessType from core.errors.exceptions import * from core.errors.logger import logger from core.services.networking.general_connection_tools.testing_evaluating import await_connection, system_uses_wireguard_interface, await_network_interface from core.services.networking.systemwide.systemwide_wireguard import establish_system_connection, terminate_system_connection from core.services.config_tools.endpoint_verification import verify_wireguard_endpoint from core.observers.TicketObserver import TicketObserver from core.services.networking.systemwide.general_tools.test_any_protocol import test_session_ip from core.models.enum_models import ProtocolChoice from core.models.session.SessionState import SessionState from collections.abc import Callable from core.Constants import Constants from core.Errors import ConnectionUnprotectedError, ConnectionTerminationError, CommandNotFoundError from core.controllers.ConfigurationController import ConfigurationController from core.controllers.SystemStateController import SystemStateController from core.models.BaseProfile import ProfileType from core.models.session.SessionProfile import SessionProfile from core.models.system.SystemProfile import SystemProfile from core.models.system.SystemState import SystemState from core.observers.ConnectionObserver import ConnectionObserver from core.services.WebServiceApiService import WebServiceApiService from essentials.modules.TorModule import TorModule from essentials.services.ConnectionService import ConnectionService from pathlib import Path from subprocess import CalledProcessError from typing import Union, Optional, Any import os import random import shutil import subprocess import tempfile import time from enum import Enum class ConnectionController: @staticmethod def with_preferred_connection(*args, task: Callable[..., Any], connection_observer: Optional[ConnectionObserver] = None, **kwargs): """ This function does a task with a preferred connection type. It is currently being CALLED UPON with keyword based kwargs only, because any args would execute immediately. However, the *args keeps it open to future uses. """ connection = ConfigurationController.get_connection() if connection == 'system': return task(*args, **kwargs) elif connection == 'tor': return ConnectionController.__with_tor_connection(*args, task=task, connection_observer=connection_observer, **kwargs) else: return None @staticmethod def establish_tor_connection(connection_observer: Optional[ConnectionObserver] = None): try: tor_module = TorModule(Constants.HV_TOR_STATE_HOME) tor_module.start_service(connection_observer) for session_state in SessionStateController.all(): for port_number in session_state.network_port_numbers.tor: tor_module.create_session(port_number) except: if connection_observer is not None: connection_observer.notify('custom_message', "Tor Can't Initialize") @staticmethod def establish_tor_session_connection(port_number: int, connection_observer: Optional[ConnectionObserver] = None) -> Result: try: tor_module = TorModule(Constants.HV_TOR_STATE_HOME) tor_module.create_session(port_number, connection_observer) return Result(valid=True) except Exception as e: error_msg = f"Tor Can't Start: {e}" logger.error(error_msg) if connection_observer is not None: connection_observer.notify('custom_message', "Tor Can't Initialize") return Result(valid=False, error_type=ResultError.TOR, message=error_msg) @staticmethod def terminate_tor_session_connection(port_number: int): tor_module = TorModule(Constants.HV_TOR_STATE_HOME) tor_module.destroy_session(port_number) @staticmethod def establish_proxy_session_connection(profile: SessionProfile, session_directory: str, port_number: int, proxy_port_number: int) -> Result: if shutil.which('proxychains4') is None: raise CommandNotFoundError('proxychains4') if shutil.which('microsocks') is None: raise CommandNotFoundError('microsocks') if profile.has_proxy_configuration(): proxy_configuration = profile.get_proxy_configuration() else: return Result(valid=False, error_type=ResultError.MISSING_DATA, message='No valid proxy configuration file detected.') proxy_session_directory = f'{session_directory}/proxy' Path(proxy_session_directory).mkdir(parents=True, exist_ok=True, mode=0o700) proxychains_proxy_list = '' if port_number is not None: proxychains_proxy_list = f'socks5 127.0.0.1 {port_number}\n' proxychains_proxy_list = proxychains_proxy_list + f'socks5 {proxy_configuration.ip_address} {proxy_configuration.port_number} {proxy_configuration.username} {proxy_configuration.password}' proxychains_template_file_path = f'{Constants.HV_RUNTIME_DATA_HOME}/proxychains.ptpl' with open(proxychains_template_file_path, 'r') as proxychains_template_file: proxychains_configuration_file_path = f'{proxy_session_directory}/proxychains.conf' Path(proxychains_configuration_file_path).touch(exist_ok=True, mode=0o600) proxychains_configuration_file_contents = proxychains_template_file.read().format(proxy_list=proxychains_proxy_list) with open(proxychains_configuration_file_path, 'w') as proxychains_configuration_file: proxychains_configuration_file.write(proxychains_configuration_file_contents) network_process = subprocess.Popen(('proxychains4', '-f', proxychains_configuration_file_path, 'microsocks', '-p', str(proxy_port_number)), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) return Result(valid=True, data=network_process) # Stays here for Tor based only. Will move with Tor later. @staticmethod def get_proxies(port_number: int): return dict( http=f'socks5h://127.0.0.1:{port_number}', https=f'socks5h://127.0.0.1:{port_number}' ) @staticmethod def __with_tor_connection(*args, task: Callable[..., Any], connection_observer: Optional[ConnectionObserver] = None, **kwargs): port_number = ConnectionService.get_random_available_port_number() ConnectionController.establish_tor_session_connection(port_number, connection_observer=connection_observer) await_connection(port_number, connection_observer=connection_observer) task_output = task(*args, proxies=ConnectionController.get_proxies(port_number), **kwargs) ConnectionController.terminate_tor_session_connection(port_number) return task_output