Session wireguard profiles switched over to the new state management system

This commit is contained in:
SimplifiedPrivacy 2026-11-01 16:46:27 -05:00
parent af3050106f
commit 257bb952f7
14 changed files with 869 additions and 117 deletions

View file

@ -8,6 +8,7 @@ from core.observers.TicketObserver import TicketObserver
from core.services.networking.systemwide.general_tools.test_any_protocol import test_session_ip from core.services.networking.systemwide.general_tools.test_any_protocol import test_session_ip
from core.models.enum_models import ProtocolChoice from core.models.enum_models import ProtocolChoice
from core.models.session.SessionState import SessionState
from collections.abc import Callable from collections.abc import Callable
from core.Constants import Constants from core.Constants import Constants
from core.Errors import ConnectionUnprotectedError, ConnectionTerminationError, CommandNotFoundError from core.Errors import ConnectionUnprotectedError, ConnectionTerminationError, CommandNotFoundError
@ -61,71 +62,70 @@ class ConnectionController:
return None return None
@staticmethod # @staticmethod
def establish_session_connection(profile: SessionProfile, ignore: tuple[type[Exception]] = (), connection_observer: Optional[ConnectionObserver] = None, ticket_observer: Optional[TicketObserver] = None): # 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_directory = tempfile.mkdtemp(prefix='hv-')
session_state = SessionStateController.get_or_new(profile.id) # session_state = SessionStateController.get_or_new(profile.id)
port_number = None # port_number = None
proxy_port_number = None # proxy_port_number = None
# this is a check from SessionConnection of if there's a systemwide with mask # # this is a check from SessionConnection of if there's a systemwide with mask
if profile.connection.is_unprotected(): # if profile.connection.is_unprotected():
if not system_uses_wireguard_interface(): # if not system_uses_wireguard_interface():
if not ConnectionUnprotectedError in ignore: # if not ConnectionUnprotectedError in ignore:
raise ConnectionUnprotectedError('Connection unprotected while the system is not using a WireGuard interface.') # raise ConnectionUnprotectedError('Connection unprotected while the system is not using a WireGuard interface.')
else: # else:
from core.services.profiles.profile_connections import disable_profile # from core.services.profiles.profile_connections import disable_profile
disable_profile(profile=profile, connection_observer=connection_observer, ticket_observer=ticket_observer) # disable_profile(profile=profile, connection_observer=connection_observer, ticket_observer=ticket_observer)
if profile.connection.code == 'tor': # if profile.connection.code == 'tor':
port_number = ConnectionService.get_random_available_port_number() # port_number = ConnectionService.get_random_available_port_number()
ConnectionController.establish_tor_session_connection(port_number, connection_observer=connection_observer) # ConnectionController.establish_tor_session_connection(port_number, connection_observer=connection_observer)
session_state.network_port_numbers.tor.append(port_number) # session_state.network_port_numbers.tor.append(port_number)
elif profile.connection.code == 'wireguard': # elif profile.connection.code == 'wireguard':
if ConfigurationController.get_endpoint_verification_enabled(): # if ConfigurationController.get_endpoint_verification_enabled():
verify_wireguard_endpoint(profile, ignore=ignore) # verify_wireguard_endpoint(profile, ignore=ignore)
port_number = ConnectionService.get_random_available_port_number() # port_number = ConnectionService.get_random_available_port_number()
ConnectionController.establish_wireguard_session_connection(profile, session_directory, port_number) # ConnectionController.establish_wireguard_session_connection(profile, session_directory, port_number)
session_state.network_port_numbers.wireguard.append(port_number) # session_state.network_port_numbers.wireguard.append(port_number)
if profile.connection.masked: # if profile.connection.masked:
while proxy_port_number is None or proxy_port_number == port_number: # while proxy_port_number is None or proxy_port_number == port_number:
proxy_port_number = ConnectionService.get_random_available_port_number() # proxy_port_number = ConnectionService.get_random_available_port_number()
ConnectionController.establish_proxy_session_connection(profile, session_directory, port_number, proxy_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) # session_state.network_port_numbers.proxy.append(proxy_port_number)
# if not profile.connection.is_unprotected(): # # if not profile.connection.is_unprotected():
if profile.connection.code == 'wireguard': # if profile.connection.code == 'wireguard':
test_result = test_session_ip(port=port_number, profile_id=profile.id, protocol=ProtocolChoice.WIREGUARD, connection_observer=connection_observer) # test_result = test_session_ip(port=port_number, profile_id=profile.id, protocol=ProtocolChoice.WIREGUARD, connection_observer=connection_observer)
if test_result.valid: # if test_result.valid:
logger.info("Connection established.") # logger.info("Connection established.")
if connection_observer: # if connection_observer:
connection_observer.notify("connected", "Confirmed") # connection_observer.notify("connected", "Confirmed")
else: # else:
logger.error(test_result.message) # logger.error(test_result.message)
raise ConnectionError(test_result.message) # return test_result.wrap("Unable to connect in ConnectionController.")
elif profile.connection.code == 'tor': # elif profile.connection.code == 'tor':
await_connection(proxy_port_number or port_number, connection_observer=connection_observer) # await_connection(proxy_port_number or port_number, connection_observer=connection_observer)
SessionStateController.update_or_create(session_state) # SessionStateController.update_or_create(session_state)
return proxy_port_number or port_number
# return proxy_port_number or port_number
@staticmethod @staticmethod
@ -149,14 +149,18 @@ class ConnectionController:
# tor_module.stop_service() # tor_module.stop_service()
@staticmethod @staticmethod
def establish_tor_session_connection(port_number: int, connection_observer: Optional[ConnectionObserver] = None): def establish_tor_session_connection(port_number: int, connection_observer: Optional[ConnectionObserver] = None) -> Result:
try: try:
tor_module = TorModule(Constants.HV_TOR_STATE_HOME) tor_module = TorModule(Constants.HV_TOR_STATE_HOME)
tor_module.create_session(port_number, connection_observer) tor_module.create_session(port_number, connection_observer)
return Result(valid=True)
except Exception as e: except Exception as e:
logger.error(f"Tor Can't Start: {e}") error_msg = f"Tor Can't Start: {e}"
logger.error(error_msg)
if connection_observer is not None: if connection_observer is not None:
connection_observer.notify('custom_message', "Tor Can't Initialize") connection_observer.notify('custom_message', "Tor Can't Initialize")
return Result(valid=False, error_type=ResultError.TOR, message=error_msg)
@staticmethod @staticmethod
def terminate_tor_session_connection(port_number: int): def terminate_tor_session_connection(port_number: int):
@ -164,25 +168,25 @@ class ConnectionController:
tor_module = TorModule(Constants.HV_TOR_STATE_HOME) tor_module = TorModule(Constants.HV_TOR_STATE_HOME)
tor_module.destroy_session(port_number) tor_module.destroy_session(port_number)
@staticmethod # @staticmethod
def establish_wireguard_session_connection(profile: SessionProfile, session_directory: str, port_number: int): # def establish_wireguard_session_connection(profile: SessionProfile, session_directory: str, port_number: int):
if not profile.has_wireguard_configuration(): # if not profile.has_wireguard_configuration():
raise FileNotFoundError('Web service did not give us a WireGuard configuration, meaning the location is likely down.') # raise FileNotFoundError('Web service did not give us a WireGuard configuration, meaning the location is likely down.')
wireguard_session_directory = f'{session_directory}/wireguard' # wireguard_session_directory = f'{session_directory}/wireguard'
Path(wireguard_session_directory).mkdir(exist_ok=True, mode=0o700) # Path(wireguard_session_directory).mkdir(exist_ok=True, mode=0o700)
wireproxy_configuration_file_path = f'{wireguard_session_directory}/wireproxy.conf' # wireproxy_configuration_file_path = f'{wireguard_session_directory}/wireproxy.conf'
Path(wireproxy_configuration_file_path).touch(exist_ok=True, mode=0o600) # Path(wireproxy_configuration_file_path).touch(exist_ok=True, mode=0o600)
with open(wireproxy_configuration_file_path, 'w') as wireproxy_configuration_file: # 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') # 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) # return subprocess.Popen((f'{Constants.HV_RUNTIME_DATA_HOME}/wireproxy/wireproxy', '-c', wireproxy_configuration_file_path), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
@staticmethod @staticmethod
def establish_proxy_session_connection(profile: SessionProfile, session_directory: str, port_number: int, proxy_port_number: int): def establish_proxy_session_connection(profile: SessionProfile, session_directory: str, port_number: int, proxy_port_number: int) -> Result:
if shutil.which('proxychains4') is None: if shutil.which('proxychains4') is None:
raise CommandNotFoundError('proxychains4') raise CommandNotFoundError('proxychains4')
@ -193,7 +197,7 @@ class ConnectionController:
if profile.has_proxy_configuration(): if profile.has_proxy_configuration():
proxy_configuration = profile.get_proxy_configuration() proxy_configuration = profile.get_proxy_configuration()
else: else:
raise FileNotFoundError('No valid proxy configuration file detected.') return Result(valid=False, error_type=ResultError.MISSING_DATA, message='No valid proxy configuration file detected.')
proxy_session_directory = f'{session_directory}/proxy' proxy_session_directory = f'{session_directory}/proxy'
Path(proxy_session_directory).mkdir(parents=True, exist_ok=True, mode=0o700) Path(proxy_session_directory).mkdir(parents=True, exist_ok=True, mode=0o700)
@ -216,7 +220,8 @@ class ConnectionController:
with open(proxychains_configuration_file_path, 'w') as proxychains_configuration_file: with open(proxychains_configuration_file_path, 'w') as proxychains_configuration_file:
proxychains_configuration_file.write(proxychains_configuration_file_contents) proxychains_configuration_file.write(proxychains_configuration_file_contents)
return subprocess.Popen(('proxychains4', '-f', proxychains_configuration_file_path, 'microsocks', '-p', str(proxy_port_number)), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) 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)
@ -242,3 +247,50 @@ class ConnectionController:
ConnectionController.terminate_tor_session_connection(port_number) ConnectionController.terminate_tor_session_connection(port_number)
return task_output return task_output
def start_tor_session_networking(
port_number: int,
session_state: SessionState,
profile: SessionProfile,
ignore: tuple[type[Exception]] = (),
connection_observer: Optional[ConnectionObserver] = None
) -> Result:
print("Starting a Tor Session Profile")
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)

View file

@ -1,30 +1,122 @@
from core.infrastructure.state_management.kill_processes import kill_all_associated_processes
from core.models.session.SessionState import SessionState from core.models.session.SessionState import SessionState
from core.controllers.ProfileController import ProfileController # from core.controllers.ProfileController import ProfileController
from core.infrastructure.global_state import ProfileStateRepository from core.infrastructure.global_state import ProfileStateRepository, ProcessType, LIST_OF_PROCESSES
from core.observers.Notifications import Notifications, EventType from core.observers.Notifications import Notifications, EventType
from core.models.Result import Result, ResultError
from core.errors.logger import logger
import subprocess
class SessionStateController: class SessionStateController:
@staticmethod @staticmethod
def get(id: int): def get_model(profile_id: int):
return SessionState.find_by_id(id) return SessionState.find_by_id(profile_id)
@staticmethod @staticmethod
def get_or_new(id: int): def get_or_new(profile_id: int):
session_state = SessionStateController.get(id) session_state = SessionStateController.get_model(profile_id)
if session_state is None: if session_state is None:
# Update the Singleton Repo # Update the Singleton Repo
repo = ProfileStateRepository() repo = ProfileStateRepository()
repo.sync_session_added(id) repo.setup_session_profile(profile_id)
# Create and save the session # Create and save the session
session_state = SessionState(id) session_state = SessionState(profile_id)
session_state.save() session_state.save()
return session_state return session_state
return session_state return session_state
@staticmethod
def kill_session_profile(profile_id: int) -> Result:
# get process objects from repo:
repo = ProfileStateRepository()
for each_process_type in LIST_OF_PROCESSES:
each_process = repo.get_session_process(profile_id=profile_id, process_type=each_process_type)
try:
pid = each_process.pid
print(f"Killing process type {each_process_type} with a pid of {pid}")
each_process.kill()
# Wait for the process to actually exit and clean up
exit_code = each_process.wait()
print(f"Process {each_process_type} terminated with code {exit_code}")
continue
except ProcessLookupError:
print("Process was already dead or terminated prior. But we continue")
continue
except AttributeError:
print("Process variable was never initialized. But we continue")
continue
except OSError as e:
pid_label = pid if 'pid' in locals() else "unknown"
# Catch-all for other OS-level failures (e.g., permission issues)
error_msg = f"Failed to kill process {each_process_type} with pid: {pid_label} and error: {e}"
logger.error(error_msg)
return Result(valid=False, error_type=ResultError.STATE, message=error_msg)
# Clear the repo:
print("Clearing the repo")
repo.remove_session_profile(profile_id)
# Delete model:
SessionState.remove_file(id=profile_id)
return Result(valid=True)
@staticmethod
def new(profile_id: int):
# model
session_state = SessionState(profile_id)
session_state.save()
# repo
repo = ProfileStateRepository()
repo.setup_session_profile(profile_id)
@staticmethod
def add_process(profile_id: int, process_type: ProcessType, process: subprocess.Popen):
repo = ProfileStateRepository()
repo.add_session_process(profile_id=profile_id, process_type=process_type, process=process)
@staticmethod
def remove_process(profile_id: int, process_type: ProcessType):
repo = ProfileStateRepository()
repo.add_session_process(profile_id=profile_id, process_type=process_type, process=None)
@staticmethod
def activate(profile_id: int) -> bool:
repo = ProfileStateRepository()
activated = repo.flip_session_profile_on(profile_id=profile_id)
if not activated:
logger.error("Called activate, when the processes weren't ready to do so.")
return False
# notify UI:
logger.info(f"Activated profile {profile_id}")
Notifications.emit(EventType.SESSION_PROFILE_ENABLE, profile_id)
notification = f"Profile {profile_id} enabled."
Notifications.emit(EventType.STATUS_UPDATE, notification)
return True
@staticmethod
def get_repo(id: int):
repo = ProfileStateRepository()
return repo.get_entire_session_process_group(int)
@staticmethod @staticmethod
def exists(id: int): def exists(id: int):
return SessionState.exists(id) return SessionState.exists(id)
@ -42,18 +134,43 @@ class SessionStateController:
profile_id = session_state.id profile_id = session_state.id
# Ensure repo knows this session exists # Ensure repo knows this session exists
ProfileStateRepository().sync_session_added(profile_id) ProfileStateRepository().setup_session_profile(profile_id)
# notify UI: # # notify UI:
Notifications.emit(EventType.SESSION_PROFILE_ENABLE, profile_id) # Notifications.emit(EventType.SESSION_PROFILE_ENABLE, profile_id)
@staticmethod @staticmethod
def remove(profile_id: int): def remove(profile_id: int):
# save to model: # save to model:
print("dissolving model")
SessionState.dissolve(profile_id) SessionState.dissolve(profile_id)
# cache: # cache:
ProfileStateRepository().sync_session_removed(profile_id) print("removing from cache repo")
repo = ProfileStateRepository()
repo.remove_session_profile(profile_id)
# notify UI: # notify UI:
print("sending")
Notifications.emit(EventType.SESSION_PROFILE_DISABLE, profile_id) Notifications.emit(EventType.SESSION_PROFILE_DISABLE, profile_id)
@staticmethod
def scortched_earth_kill_profile(profile_id: int) -> bool:
session_state = SessionStateController.get_model(profile_id)
if session_state:
killed = kill_all_associated_processes(session_state)
# delete model:
SessionState.remove_file(profile_id)
# cache:
print("removing from cache repo")
repo = ProfileStateRepository()
repo.remove_session_profile(profile_id)
# notify UI:
print("sending")
Notifications.emit(EventType.SESSION_PROFILE_DISABLE, profile_id)
return True

View file

@ -4,19 +4,35 @@ from core.models.session.SessionState import SessionState
from core.models.enum_models import ProtocolChoice from core.models.enum_models import ProtocolChoice
from dataclasses import dataclass, field from dataclasses import dataclass, field
from typing import Optional from typing import Optional, Dict
import subprocess
from enum import Enum
class ProcessType(Enum):
NETWORK = "network"
APP = "app"
DISPLAY = "display"
ACTIVE = "active"
LIST_OF_PROCESSES = [ProcessType.APP, ProcessType.DISPLAY, ProcessType.NETWORK]
@dataclass @dataclass
class GlobalState: class GlobalState:
# systemwide:
systemwide_active: bool = False systemwide_active: bool = False
protocol: ProtocolChoice = None protocol: ProtocolChoice = None
firewalled: bool = False firewalled: bool = False
dns_set: bool = False dns_set: bool = False
systemwide_profile_id: Optional[int] = None systemwide_profile_id: Optional[int] = None
session_profile_ids: list[int] = field(default_factory=list)
verified_working: bool = False verified_working: bool = False
changed_port: bool = False changed_port: bool = False
# session:
# session_profile_ids: list[int] = field(default_factory=list)
session_profiles: Dict[str, Dict[ProcessType, subprocess.Popen]] = field(default_factory=dict)
class ProfileStateRepository: class ProfileStateRepository:
_instance = None _instance = None
@ -38,6 +54,24 @@ class ProfileStateRepository:
# Load existing session IDs from disk into the list # Load existing session IDs from disk into the list
self.global_state.session_profile_ids = [s.id for s in SessionState.all()] self.global_state.session_profile_ids = [s.id for s in SessionState.all()]
@property
def current_session_ids(self) -> list[int]:
"""Returns current session profile ids."""
return list(self.global_state.session_profiles.keys())
@property
def active_session_ids(self) -> list[int]:
"""Returns active session profile ids."""
print("getting active session ids")
current_list = self.current_session_ids
active_list = []
for each_profile_id in current_list:
if self.global_state.session_profiles[each_profile_id][ProcessType.ACTIVE] is True:
active_list.append(each_profile_id)
return active_list
def turn_off_system_connection(self): def turn_off_system_connection(self):
"""Clear the system-wide memory cache.""" """Clear the system-wide memory cache."""
self.global_state.systemwide_profile_id = None self.global_state.systemwide_profile_id = None
@ -59,7 +93,7 @@ class ProfileStateRepository:
def verify_its_up(self, profile_id: int) -> bool: def verify_its_up(self, profile_id: int) -> bool:
"""Flips on Verification, if the rest of the state matches""" """Flips on Verification for Systemwide, if the rest of the state matches"""
if not self.global_state.systemwide_active: if not self.global_state.systemwide_active:
return False return False
@ -73,21 +107,69 @@ class ProfileStateRepository:
Notifications.emit(EventType.SYSTEM_ENABLE, profile_id) Notifications.emit(EventType.SYSTEM_ENABLE, profile_id)
return True return True
def sync_session_added(self, profile_id: int):
"""Called by SessionStateController to update memory cache."""
if profile_id not in self.global_state.session_profile_ids:
self.global_state.session_profile_ids.append(profile_id)
def sync_session_removed(self, profile_id: int):
"""Called by SessionStateController to update memory cache."""
if profile_id in self.global_state.session_profile_ids:
self.global_state.session_profile_ids.remove(profile_id)
def is_profile_active(self, profile_id: int) -> bool: def is_profile_active(self, profile_id: int) -> bool:
# Check system profile # Check system profile
if self.global_state.systemwide_active and self.global_state.systemwide_profile_id == profile_id: if self.global_state.systemwide_active and self.global_state.systemwide_profile_id == profile_id:
return True return True
# Check session profiles # Check session profiles
return profile_id in self.global_state.session_profile_ids return profile_id in self.active_session_ids
def setup_session_profile(self, profile_id: int) -> None:
"""Ensures a session profile exists in the registry without overwriting existing processes."""
self.global_state.session_profiles.setdefault(profile_id, {})
def add_session_process(self, profile_id: int, process_type: ProcessType, process: subprocess.Popen|bool) -> None:
"""Adds a live process to a specific profile id group."""
self.setup_session_profile(profile_id)
self.global_state.session_profiles[profile_id][process_type] = process
def get_entire_session_process_group(self, profile_id: int) -> Optional[Dict[ProcessType, subprocess.Popen]]:
"""Returns the entire dictionary of processes for a group, or None if not found."""
return self.global_state.session_profiles.get(profile_id)
def flip_session_profile_on(self, profile_id: int) -> bool:
"""If it has all the pre-reqs, then it sets the status to on."""
for each_type in LIST_OF_PROCESSES:
if self.global_state.session_profiles[profile_id][each_type] is None:
print(f"Process is none for {each_type}")
return False
print("Global state is setting the session profile to activated")
self.global_state.session_profiles[profile_id][ProcessType.ACTIVE] = True
return True
def get_session_process(self, profile_id: int, process_type: ProcessType) -> Optional[subprocess.Popen]:
"""Gets a single process from the session profile's group."""
# 1. Leverage the group getter
group = self.get_entire_session_process_group(profile_id)
# 2. If the group exists, try to get the specific process
if group:
return group.get(process_type)
return None
def remove_session_profile(self, profile_id: int) -> None:
""" Completely remove a profile, and it's group of processes from the registry"""
if profile_id in self.global_state.session_profiles:
del self.global_state.session_profiles[profile_id]
# def sync_session_added(self, profile_id: int):
# """Called by SessionStateController to update memory cache."""
# if profile_id not in self.global_state.session_profile_ids:
# self.global_state.session_profile_ids.append(profile_id)
# def sync_session_removed(self, profile_id: int):
# """Called by SessionStateController to update memory cache."""
# if profile_id in self.global_state.session_profile_ids:
# self.global_state.session_profile_ids.remove(profile_id)

View file

@ -51,7 +51,7 @@ def connected_system_profile_id() -> int|None:
def connected_session_profile_ids() -> list|None: def connected_session_profile_ids() -> list|None:
"""Returns a list of the currently connected session profile IDs""" """Returns a list of the currently connected session profile IDs"""
state_repo = ProfileStateRepository() state_repo = ProfileStateRepository()
return state_repo.global_state.session_profile_ids return state_repo.active_session_ids
def get_all_connected() -> list|None: def get_all_connected() -> list|None:
@ -225,7 +225,7 @@ def evaluate_state_on_startup() -> Result:
if active_session_profiles: if active_session_profiles:
for each_session in active_session_profiles: for each_session in active_session_profiles:
logger.info(f"Killing profile {each_session}") logger.info(f"Killing profile {each_session}")
Notifications.emit(EventType.SESSION_PROFILE_KILL, each_session) Notifications.emit(EventType.SESSION_PROFILE_KILL, each_session.id)
time.sleep(4) time.sleep(4)
return Result(valid=True) return Result(valid=True)

View file

@ -0,0 +1,35 @@
from core.models.session.SessionState import SessionState
import psutil
def kill_all_associated_processes(session_state: SessionState) -> bool:
associated_process_ids = list(session_state.process_ids)
network_connections = psutil.net_connections()
for network_port_number in session_state.network_port_numbers.isolated:
for network_connection in network_connections:
if network_connection.laddr != tuple() and network_connection.laddr.port == network_port_number:
if network_connection.pid is not None:
associated_process_ids.append(network_connection.pid)
if network_connection.raddr != tuple() and network_connection.raddr.port == network_port_number:
if network_connection.pid is not None:
associated_process_ids.append(network_connection.pid)
for process in psutil.process_iter():
if process.pid in associated_process_ids and process.is_running():
for child_process in process.children(True):
child_process.kill()
print("killing process")
process.kill()
return True

View file

@ -19,6 +19,7 @@ class ResultError(Enum):
SETUP_SINGBOX = "setup_singbox" SETUP_SINGBOX = "setup_singbox"
FILE_SYSTEM = "filesystem" FILE_SYSTEM = "filesystem"
CONNECTION = "connection" CONNECTION = "connection"
TOR = "tor"
DATABASE = "database" DATABASE = "database"
PERMISSION = "permission" PERMISSION = "permission"
SUBSCRIPTION = "subscription" SUBSCRIPTION = "subscription"

View file

@ -6,6 +6,7 @@ class ProtocolChoice(Enum):
HYSTERIA2 = "hysteria2" HYSTERIA2 = "hysteria2"
VLESS = "vless" VLESS = "vless"
SOCK5_PROXY = "proxy" SOCK5_PROXY = "proxy"
TOR = "tor"
# MASKED_WIREGUARD = "masked_wireguard" # MASKED_WIREGUARD = "masked_wireguard"
SINGBOX_PROTOCOLS = [ProtocolChoice.HYSTERIA2, ProtocolChoice.VLESS] SINGBOX_PROTOCOLS = [ProtocolChoice.HYSTERIA2, ProtocolChoice.VLESS]

View file

@ -89,6 +89,20 @@ class SessionState:
return session_states return session_states
@staticmethod
def remove_file(id: int):
session_state = SessionState.find_by_id(id)
if session_state is not None:
session_state_path = session_state.get_state_path()
print(f"Removing state file for profile {id}")
shutil.rmtree(session_state_path, ignore_errors=True)
@staticmethod @staticmethod
def dissolve(id: int): def dissolve(id: int):
@ -99,6 +113,8 @@ class SessionState:
session_state_path = session_state.get_state_path() session_state_path = session_state.get_state_path()
SessionState.__kill_associated_processes(session_state) SessionState.__kill_associated_processes(session_state)
print(f"Removing state file for profile {id}")
shutil.rmtree(session_state_path, ignore_errors=True) shutil.rmtree(session_state_path, ignore_errors=True)
@staticmethod @staticmethod
@ -128,6 +144,7 @@ class SessionState:
for child_process in process.children(True): for child_process in process.children(True):
child_process.kill() child_process.kill()
print("killing process")
process.kill() process.kill()
@staticmethod @staticmethod

View file

@ -0,0 +1,60 @@
from core.models.session.SessionProfile import SessionProfile
from core.models.Result import Result, ResultError
import os
import re
import subprocess
import time
import shutil
def find_unused_display() -> str:
"""Get a string of an unused X11 display port"""
file_names = os.listdir('/tmp/.X11-unix')
active_displays = []
for file_name in file_names:
match_object = re.search(r'X(\d+)', file_name)
if match_object:
detected_display = int(match_object.group(1))
if 170 <= detected_display <= 198:
active_displays.append(detected_display)
if len(active_displays) > 0:
unused_display = sorted(active_displays)[-1] + 1
return f':{str(unused_display)}'
else:
return ':170'
def launch_xephyr(profile: SessionProfile, display: str) -> Result:
"""Run Xephyr with the correct display, and get it's persistent Popen object"""
if shutil.which('Xephyr') is None:
return Result(valid=False, error_type=ResultError.MISSING_DEPENDENCY, message="Xephyr pre-req is missing.")
virtual_display_process = subprocess.Popen(('Xephyr', '-ac', '-br', '-title', f'HydraVeil - {profile.name or "Unnamed Profile"}', '-screen', profile.resolution, '-no-host-grab', display), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
start_time = time.time()
timeout = float(10)
while not os.path.exists(f'/tmp/.X11-unix/X{display[1:]}'):
if time.time() - start_time < timeout:
time.sleep(0.1)
else:
virtual_display_process.kill()
return
return Result(valid=True, data=virtual_display_process)

View file

@ -0,0 +1,18 @@
PREFERRED_FONT_FAMILIES = [
'adwaita-sans-fonts',
'dejavu',
'droid',
'google-droid-sans-fonts',
'google-noto-sans-cjk-vf-fonts',
'google-noto-sans-mono-cjk-vf-fonts',
'liberation',
'liberation-sans-fonts',
'libreoffice',
'noto',
'open-sans',
'ubuntu'
]

View file

@ -0,0 +1,51 @@
from core.services.apps.font_families import PREFERRED_FONT_FAMILIES
from core.models.orm_models.ApplicationVersion import ApplicationVersion
from core.models.session.SessionProfile import SessionProfile
from core.models.Result import Result
# generic
from pathlib import Path
import os
import random
import shutil
def _select_random_font(items: list, preferred_items: list, limit: int):
"""Select a font from the available choices"""
available_preferred_items = [item for item in preferred_items if item in items]
selectable_items = [item for item in items if item not in preferred_items]
selected_items = random.sample(selectable_items, random.randint(0, min(limit, len(selectable_items))))
return selected_items + available_preferred_items
def prepare_fonts(
profile: SessionProfile,
version: ApplicationVersion,
persistent_state_path: str
) -> Result:
"""Write the fonts for this app version to the bash script's init"""
font_path = f'{profile.get_data_path()}/fonts'
if not os.path.isdir(persistent_state_path) or len(os.listdir(persistent_state_path)) == 0:
shutil.copytree(f'{version.get_installation_path()}/resources/initial-state', persistent_state_path)
if (not os.path.isdir(font_path) or len(os.listdir(font_path)) == 0) and os.path.isdir('/usr/share/fonts'):
if os.path.isdir('/usr/share/fonts/truetype'):
truetype_fonts_path = '/usr/share/fonts/truetype'
else:
truetype_fonts_path = '/usr/share/fonts'
font_families = [file.name for file in Path(truetype_fonts_path).iterdir() if file.is_dir()]
font_family_subset = _select_random_font(font_families, PREFERRED_FONT_FAMILIES, 12)
for font_family in font_family_subset:
shutil.copytree(f'{truetype_fonts_path}/{font_family}', f'{font_path}/{font_family}')
return Result(valid=True)

View file

@ -0,0 +1,150 @@
from core.observers.Notifications import Notifications, EventType
from core.services.apps.display import find_unused_display, launch_xephyr
from core.services.apps.fonts import prepare_fonts
from core.infrastructure.global_state import ProcessType
from core.Constants import Constants
from core.controllers.SessionStateController import SessionStateController
from core.models.orm_models.ApplicationVersion import ApplicationVersion
from core.models.session.SessionProfile import SessionProfile
from core.models.Result import Result, ResultError
from core.errors.logger import logger
# generic
from pathlib import Path
import os
import shutil
import stat
import subprocess
def literally_launch_app(
initialization_file_path: str,
profile: SessionProfile,
display: str
) -> Result:
"""Screen for the required pre-reqs, and launch the bash script with the correct env file."""
if shutil.which('bwrap') is None:
return Result(valid=False, error_type=ResultError.MISSING_DEPENDENCY, message="bwrap pre-req is missing.")
if shutil.which('ratpoison') is None:
return Result(valid=False, error_type=ResultError.MISSING_DEPENDENCY, message="ratpoison pre-req is missing.")
environment = os.environ.copy()
environment.update({'DISPLAY': display})
app_process = subprocess.Popen(initialization_file_path, env=environment)
return Result(valid=True, data=app_process)
def prepare_initialization_file(
profile: SessionProfile,
display: str,
time_zone: str,
version: ApplicationVersion,
port_number: int
) -> str:
"""Prepare the application's init file"""
runtime_initialization_file_template = open(f'/{Constants.HV_RUNTIME_DATA_HOME}/.init.ptpl', 'r').read()
runtime_initialization_file_contents = runtime_initialization_file_template.format(display=display, time_zone=time_zone, hv_runtime_data_home=Constants.HV_RUNTIME_DATA_HOME)
application_initialization_file_template = open(f'/{version.get_installation_path()}/.init.ptpl', 'r').read()
application_initialization_file_contents = application_initialization_file_template.format(application_version_home=version.get_installation_path(), port_number=port_number or -1, home=Constants.HOME, profile_data_path=profile.get_data_path(), config_home=Constants.CONFIG_HOME, application_version_number=version.version_number)
initialization_file_contents = runtime_initialization_file_contents + application_initialization_file_contents
initialization_file_path = f'{Constants.HV_SESSION_STATE_HOME}/{str(profile.id)}/.init'
Path(initialization_file_path).touch(exist_ok=True, mode=0o600 | stat.S_IEXEC)
with open(initialization_file_path, 'w') as initialization_file:
initialization_file.write(initialization_file_contents)
return initialization_file_path
def orchestrate_app_launch(
version: ApplicationVersion,
profile: SessionProfile,
port_number: int = None,
) -> Result:
# ----------------------------------
# PREPARE VARIABLES AND STATE
# ----------------------------------
persistent_state_path = f'{profile.get_data_path()}/persistent-state'
print("Preparing the fonts")
prepared_fonts = prepare_fonts(
profile=profile,
version=version,
persistent_state_path=persistent_state_path
)
if not prepared_fonts.valid:
return prepared_fonts.wrap("Failed to prepare the fonts.")
print("Getting the display and timezone")
display = find_unused_display()
time_zone = profile.determine_timezone()
print("Setting up the init file.")
initialization_file_path = prepare_initialization_file(
profile=profile,
display=display,
time_zone=time_zone,
version=version,
port_number=port_number
)
session_state = SessionStateController.get_or_new(profile.id)
# ----------------------------------
# DISPLAY LAUNCH
# ----------------------------------
print("Launching Xephyr")
xephyr_result = launch_xephyr(profile=profile, display=display)
if not xephyr_result.valid:
error_msg = "Unable to launch the profile's graphical display."
logger.error(error_msg)
return xephyr_result.wrap(error_msg)
virtual_display_process = xephyr_result.data
# ----------------------------------
# APP LAUNCH
# ----------------------------------
print("Literally launching the application's bash script")
app_launch_result = literally_launch_app(
initialization_file_path=initialization_file_path,
profile=profile,
display=display
)
if not app_launch_result.valid:
error_msg = "Failed to launch the app itself. Killing the display."
logger.error(error_msg)
virtual_display_process.kill()
return app_launch_result.wrap(error_msg)
app_process = app_launch_result.data
# ----------------------------------
# UPDATE STATE
# ----------------------------------
# Update Repo (in memory) with the process objects:
print("Updating Repo in memory State..")
SessionStateController.add_process(profile_id=profile.id, process_type=ProcessType.DISPLAY, process=virtual_display_process)
SessionStateController.add_process(profile_id=profile.id, process_type=ProcessType.APP, process=app_process)
# update model (on disk) with pids:
print("Updating the model on disk..")
session_state.process_ids.extend([virtual_display_process.pid, app_process.pid])
SessionStateController.update_or_create(session_state)
print("It worked. Notify & Returning..")
if SessionStateController.activate(profile.id):
return Result(valid=True)
else:
return Result(valid=False, error_type=ResultError.STATE, message="We launched the profile, but failed to activate it via the Controller & Repo")

View file

@ -0,0 +1,141 @@
from core.controllers.ConnectionController import start_tor_session_networking
from essentials.services.ConnectionService import ConnectionService
from core.services.keys_and_verifications.endpoint_verification import verify_wireguard_endpoint
from core.controllers.SessionStateController import SessionStateController
from core.models.session.SessionProfile import SessionProfile
from core.observers.ConnectionObserver import ConnectionObserver
from core.models.enum_models import ProtocolChoice
from core.errors.logger import logger
from core.models.Result import Result, ResultError
from core.infrastructure.global_state import ProcessType
from core.services.networking.systemwide.general_tools.test_any_protocol import test_session_ip
from core.controllers.ConfigurationController import ConfigurationController
from core.Constants import Constants
import subprocess
from pathlib import Path
import tempfile
from typing import Optional
def start_wireproxy(profile: SessionProfile, session_directory: str, port_number: int) -> Result:
if not profile.has_wireguard_configuration():
error_msg = f"Profile {profile.id} does not have a Wireguard configuration, meaning the API or location are down"
return Result(valid=False, error_type=ResultError.MISSING_DATA, message=error_msg)
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')
wireproxy_process = subprocess.Popen((f'{Constants.HV_RUNTIME_DATA_HOME}/wireproxy/wireproxy', '-c', wireproxy_configuration_file_path), stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
return Result(valid=True, data=wireproxy_process)
def start_session_networking(
profile: SessionProfile,
ignore: tuple[type[Exception]] = (),
connection_observer: Optional[ConnectionObserver] = None
) -> Result:
protocol = ProtocolChoice(profile.connection.code)
print(f"protocol is {protocol}")
session_directory = tempfile.mkdtemp(prefix='hv-')
session_state = SessionStateController.get_or_new(profile.id)
port_number = None
proxy_port_number = None
port_number = ConnectionService.get_random_available_port_number()
print(f"Openning on port {port_number}")
#--------------------------------
# TOR
#--------------------------------
if protocol == ProtocolChoice.TOR:
print("Passing off to ConnectionController's Tor system")
return start_tor_session_networking(port_number=port_number, session_state=session_state, profile=profile, ignore=ignore, connection_observer=connection_observer)
#--------------------------------
# WIREGUARD
#--------------------------------
elif protocol == ProtocolChoice.WIREGUARD:
# Verification
if ConfigurationController.get_endpoint_verification_enabled():
verify_wireguard_endpoint(profile, ignore=ignore)
connection_result = start_wireproxy(profile, session_directory, port_number)
session_state.network_port_numbers.wireguard.append(port_number)
#--------------------------------
# ALL CONNECTIONS
#--------------------------------
if not connection_result.valid:
return connection_result.wrap("Unable to start the network connection.")
network_process = connection_result.data
# sanity check for all networking processes:
if not network_process:
return Result(valid=False, error_type=ResultError.INVALID_INPUT, message="Missing a network process when it was confirmed earlier.")
# Test:
print("Testing IP..")
test_result = test_session_ip(port=port_number, profile_id=profile.id, protocol=protocol, connection_observer=connection_observer)
if not test_result.valid:
error_msg = "Test shows IP is not valid."
logger.error(error_msg)
network_process.kill()
logger.info("Killed process")
return test_result.wrap(error_msg)
# Update in memory repo,
SessionStateController.update_or_create(session_state)
SessionStateController.add_process(profile_id=profile.id, process_type=ProcessType.NETWORK, process=network_process)
final_port = proxy_port_number or port_number
return Result(valid=True, data=final_port)
# def kill_session_networking(profile_id: int) -> Result:
# SessionStateController.kill_session_process(profile_id=profile_id, process_type=ProcessType.NETWORK)
# return Result(valid=True)
# # 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)
# 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() and not ConnectionUnprotectedError in ignore:
# error_msg = 'Connection unprotected while the system is not using a WireGuard interface.'
# logger.error(error_msg)
# return Result(valid=False, error_type=ResultError.INVALID_INPUT, message=error_msg)
# # from core.services.profiles.profile_connections import disable_profile
# # disable_profile(profile=profile, connection_observer=connection_observer, ticket_observer=ticket_observer)

View file

@ -1,3 +1,5 @@
from core.services.apps.launch_app import orchestrate_app_launch
from core.services.networking.session.session_networking import start_session_networking
from core.observers.Notifications import Notifications, EventType from core.observers.Notifications import Notifications, EventType
from core.controllers.ConnectionController import ConnectionController from core.controllers.ConnectionController import ConnectionController
from core.controllers.ProfileController import ProfileController from core.controllers.ProfileController import ProfileController
@ -59,7 +61,6 @@ def is_enabled(profile: Union[SessionProfile, SystemProfile]) -> int | None:
def enable_session_profile( def enable_session_profile(
profile: Union[SessionProfile, SystemProfile], profile: Union[SessionProfile, SystemProfile],
ignore: tuple[type[Exception]] = (), ignore: tuple[type[Exception]] = (),
asynchronous: bool = False,
profile_observer: ProfileObserver = None, profile_observer: ProfileObserver = None,
application_version_observer: ApplicationVersionObserver = None, application_version_observer: ApplicationVersionObserver = None,
connection_observer: ConnectionObserver = None, connection_observer: ConnectionObserver = None,
@ -67,13 +68,15 @@ def enable_session_profile(
max_resolution: Optional[str] = None max_resolution: Optional[str] = None
) -> Result: ) -> Result:
""" """
Launch a session profile. Orchestrate the Launch of a session profile.
1) by starting a connnection on a port, 1) by starting a connnection on a port,
2) and then starting the application using that networking port 2) and then starting the application using that networking port
""" """
#-----------------------------------
# ASSASSIN MODE # ASSASSIN MODE
#-----------------------------------
if profile.assassin: if profile.assassin:
assassin_result = assassin_tools.create( assassin_result = assassin_tools.create(
profile=profile, profile=profile,
@ -89,22 +92,39 @@ def enable_session_profile(
profile = assassin_result.data profile = assassin_result.data
# CONCLUSION OF ASSASSIN CODE # CONCLUSION OF ASSASSIN CODE
#-----------------------------------
# APPLICATION PRE-REQ
#-----------------------------------
application_version = profile.application_version application_version = profile.application_version
if not application_version.is_installed(): if not application_version.is_installed():
ApplicationVersionController.install(application_version, application_version_observer=application_version_observer, connection_observer=connection_observer) ApplicationVersionController.install(application_version, application_version_observer=application_version_observer, connection_observer=connection_observer)
#-----------------------------------
# NETWORK CONNECTION
#-----------------------------------
try: try:
port_number = establish_connection(profile, ignore=ignore, connection_observer=connection_observer, ticket_observer=ticket_observer) network_result = start_session_networking(profile, ignore=ignore, connection_observer=connection_observer)
except ConnectionError: except EndpointVerificationError:
raise ProfileActivationError('The profile could not be enabled.') return Result(valid=False, error_type=ResultError.ENDPOINT_VERIFICATION, message=f"Verification of the endpoint failed for profile {profile.id}")
except ValueError:
raise ProfileActivationError('The profile could not be enabled.')
if profile_observer is not None: if not network_result.valid:
profile_observer.notify('enabled', profile) return network_result.wrap("Failed to start the session profile")
port_number = network_result.data
#-----------------------------------
# LAUNCH APPLICATION & GRAPHICAL
#-----------------------------------
launched = orchestrate_app_launch(
version=application_version,
profile=profile,
port_number=port_number
)
if not launched.valid:
return launched.wrap("failed to launch the app")
ApplicationController.launch(application_version, profile, port_number, asynchronous=asynchronous, profile_observer=profile_observer, ticket_observer=ticket_observer, connection_observer=connection_observer)
return Result(valid=True, data=profile.type) return Result(valid=True, data=profile.type)
@ -113,7 +133,6 @@ def enable_profile(
profile: Union[SessionProfile, SystemProfile], profile: Union[SessionProfile, SystemProfile],
ignore: tuple[type[Exception]] = (), ignore: tuple[type[Exception]] = (),
pristine: bool = False, pristine: bool = False,
asynchronous: bool = False,
profile_observer: ProfileObserver = None, profile_observer: ProfileObserver = None,
application_version_observer: ApplicationVersionObserver = None, application_version_observer: ApplicationVersionObserver = None,
connection_observer: ConnectionObserver = None, connection_observer: ConnectionObserver = None,
@ -140,7 +159,6 @@ def enable_profile(
return enable_session_profile( return enable_session_profile(
profile=profile, profile=profile,
ignore=ignore, ignore=ignore,
asynchronous=asynchronous,
profile_observer=profile_observer, profile_observer=profile_observer,
application_version_observer=application_version_observer, application_version_observer=application_version_observer,
connection_observer=connection_observer, connection_observer=connection_observer,
@ -188,6 +206,10 @@ def disable_profile(
"""Orchestrate disabling a profile.""" """Orchestrate disabling a profile."""
# if profile is None:
# burned_down = kill_all_associated_processes(profile_id=profile.id)
if profile.is_session_profile(): if profile.is_session_profile():
# START ASSASSIN SECTION # START ASSASSIN SECTION
@ -204,25 +226,30 @@ def disable_profile(
raise ProfileDeactivationError(f'Assassin NOT disabled: {assassin_result.message}') raise ProfileDeactivationError(f'Assassin NOT disabled: {assassin_result.message}')
# END ASSASSIN SECTION # END ASSASSIN SECTION
if SessionStateController.exists(profile.id): print("Using SessionStateController to kill the profile..")
killed = SessionStateController.kill_session_profile(profile_id=profile.id)
if not killed.valid:
logger.error("Direct kill failed, elevating to psutil scortched earth policy")
if not kill_all_associated_processes(profile_id=profile.id):
return killed.wrap("Failed to disable the profile.")
else:
logger.info("psutil worked to kill it.")
session_state = SessionStateController.get(profile.id) # if SessionStateController.exists(profile.id):
# session_state = SessionStateController.get(profile.id)
# if session_state is not None:
# for port_number in session_state.network_port_numbers.tor:
# ConnectionController.terminate_tor_session_connection(port_number)
# SessionStateController.remove(profile.id)
if session_state is not None: # if profile_observer is not None:
# profile_observer.notify('disabled', profile, dict(
# explicitly=explicitly,
# ))
for port_number in session_state.network_port_numbers.tor: Notifications.emit(EventType.SESSION_PROFILE_DISABLE, profile.id)
ConnectionController.terminate_tor_session_connection(port_number) notification = "Profile Disconnected."
Notifications.emit(EventType.STATUS_UPDATE, notification)
# session_state.dissolve(session_state.id)
SessionStateController.remove(profile.id)
if profile_observer is not None:
profile_observer.notify('disabled', profile, dict(
explicitly=explicitly,
))
notification = "Profile Disconnected."
Notifications.emit(EventType.STATUS_UPDATE, notification)
# ============================================================================ # ============================================================================
# SYSTEMWIDE # SYSTEMWIDE