sp-hydra-veil-core/core/controllers/ConnectionController.py

299 lines
13 KiB
Python

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.keys_and_verifications.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.ProfileController import ProfileController
# from core.controllers.SessionStateController import SessionStateController
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
# import sys
# import re
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_session_connection(profile: SessionProfile, ignore: tuple[type[Exception]] = (), connection_observer: Optional[ConnectionObserver] = None, ticket_observer: Optional[TicketObserver] = None):
# session_directory = tempfile.mkdtemp(prefix='hv-')
# session_state = SessionStateController.get_or_new(profile.id)
# port_number = None
# proxy_port_number = None
# # this is a check from SessionConnection of if there's a systemwide with mask
# if profile.connection.is_unprotected():
# if not system_uses_wireguard_interface():
# if not ConnectionUnprotectedError in ignore:
# raise ConnectionUnprotectedError('Connection unprotected while the system is not using a WireGuard interface.')
# else:
# from core.services.profiles.profile_connections import disable_profile
# disable_profile(profile=profile, connection_observer=connection_observer, ticket_observer=ticket_observer)
# if profile.connection.code == 'tor':
# port_number = ConnectionService.get_random_available_port_number()
# ConnectionController.establish_tor_session_connection(port_number, connection_observer=connection_observer)
# session_state.network_port_numbers.tor.append(port_number)
# elif profile.connection.code == 'wireguard':
# if ConfigurationController.get_endpoint_verification_enabled():
# verify_wireguard_endpoint(profile, ignore=ignore)
# port_number = ConnectionService.get_random_available_port_number()
# ConnectionController.establish_wireguard_session_connection(profile, session_directory, port_number)
# session_state.network_port_numbers.wireguard.append(port_number)
# if profile.connection.masked:
# while proxy_port_number is None or proxy_port_number == port_number:
# proxy_port_number = ConnectionService.get_random_available_port_number()
# ConnectionController.establish_proxy_session_connection(profile, session_directory, port_number, proxy_port_number)
# session_state.network_port_numbers.proxy.append(proxy_port_number)
# # if not profile.connection.is_unprotected():
# if profile.connection.code == 'wireguard':
# test_result = test_session_ip(port=port_number, profile_id=profile.id, protocol=ProtocolChoice.WIREGUARD, connection_observer=connection_observer)
# if test_result.valid:
# logger.info("Connection established.")
# if connection_observer:
# connection_observer.notify("connected", "Confirmed")
# else:
# logger.error(test_result.message)
# return test_result.wrap("Unable to connect in ConnectionController.")
# elif profile.connection.code == 'tor':
# await_connection(proxy_port_number or port_number, connection_observer=connection_observer)
# SessionStateController.update_or_create(session_state)
# return proxy_port_number or port_number
@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 terminate_tor_connection():
# tor_module = TorModule(Constants.HV_TOR_STATE_HOME)
# tor_module.stop_service()
@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_wireguard_session_connection(profile: SessionProfile, session_directory: str, port_number: int):
# if not profile.has_wireguard_configuration():
# raise FileNotFoundError('Web service did not give us a WireGuard configuration, meaning the location is likely down.')
# wireguard_session_directory = f'{session_directory}/wireguard'
# Path(wireguard_session_directory).mkdir(exist_ok=True, mode=0o700)
# wireproxy_configuration_file_path = f'{wireguard_session_directory}/wireproxy.conf'
# Path(wireproxy_configuration_file_path).touch(exist_ok=True, mode=0o600)
# with open(wireproxy_configuration_file_path, 'w') as wireproxy_configuration_file:
# wireproxy_configuration_file.write(f'WGConfig = {profile.get_wireguard_configuration_path()}\n\n[Socks5]\nBindAddress = 127.0.0.1:{str(port_number)}\n')
# return subprocess.Popen((f'{Constants.HV_RUNTIME_DATA_HOME}/wireproxy/wireproxy', '-c', wireproxy_configuration_file_path), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
@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
# def start_tor_session_networking(
# port_number: int,
# session_directory: str,
# session_state: SessionState,
# profile: SessionProfile,
# ignore: tuple[type[Exception]] = (),
# connection_observer: Optional[ConnectionObserver] = None
# ) -> Result:
# print("Starting a Tor Session Profile")
# proxy_port_number = None
# tor_connected = ConnectionController.establish_tor_session_connection(port_number, connection_observer=connection_observer)
# if not tor_connected.valid:
# return tor_connected.wrap("Failed to start Tor, for Tor->socks5")
# session_state.network_port_numbers.tor.append(port_number)
# print(f"Started Tor connection on port {port_number}")
# if profile.connection.masked:
# while proxy_port_number is None or proxy_port_number == port_number:
# proxy_port_number = ConnectionService.get_random_available_port_number()
# sock_proxy_result = ConnectionController.establish_proxy_session_connection(profile, session_directory, port_number, proxy_port_number)
# if not sock_proxy_result.valid:
# # Kill the underlying Tor right here:
# terminate_tor_session_connection(port_number=port_number)
# return sock_proxy_result.wrap("We were able to start Tor, but not the socks5 proxy masking on top of it.")
# network_process = sock_proxy_result.data
# session_state.network_port_numbers.proxy.append(proxy_port_number)
# # Update in memory repo,
# SessionStateController.update_or_create(session_state)
# SessionStateController.add_process(profile_id=profile.id, process_type=ProcessType.NETWORK, process=network_process)
# print("Awaiting the connection..")
# await_connection(proxy_port_number or port_number, connection_observer=connection_observer)
# print("Updating state..")
# SessionStateController.update_or_create(session_state)
# print("Returning final proxy port")
# final_proxy_port = proxy_port_number or port_number
# return Result(valid=True, data=final_proxy_port)