Merge branch 'dev' into feature/2689-command-and-control

src/primaite/simulator/system/applications/database_client.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from ipaddress import IPv4Address
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, Union
 from uuid import uuid4
 
 from prettytable import MARKDOWN, PrettyTable
@@ -54,6 +54,12 @@ class DatabaseClientConnection(BaseModel):
         if self.client and self.is_active:
             self.client._disconnect(self.connection_id)  # noqa
 
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(connection_id='{self.connection_id}', is_active={self.is_active})"
+
+    def __repr__(self) -> str:
+        return str(self)
+
 
 class DatabaseClient(Application, identifier="DatabaseClient"):
     """
@@ -76,7 +82,7 @@ class DatabaseClient(Application, identifier="DatabaseClient"):
     """Connection ID to the Database Server."""
     client_connections: Dict[str, DatabaseClientConnection] = {}
     """Keep track of active connections to Database Server."""
-    _client_connection_requests: Dict[str, Optional[str]] = {}
+    _client_connection_requests: Dict[str, Optional[Union[str, DatabaseClientConnection]]] = {}
     """Dictionary of connection requests to Database Server."""
     connected: bool = False
     """Boolean Value for whether connected to DB Server."""
@@ -187,7 +193,7 @@ class DatabaseClient(Application, identifier="DatabaseClient"):
             return False
         return self._query("SELECT * FROM pg_stat_activity", connection_id=connection_id)
 
-    def _check_client_connection(self, connection_id: str) -> bool:
+    def _validate_client_connection_request(self, connection_id: str) -> bool:
         """Check that client_connection_id is valid."""
         return True if connection_id in self._client_connection_requests else False
 
@@ -211,23 +217,30 @@ class DatabaseClient(Application, identifier="DatabaseClient"):
         :type: is_reattempt: Optional[bool]
         """
         if is_reattempt:
-            valid_connection = self._check_client_connection(connection_id=connection_request_id)
-            if valid_connection:
+            valid_connection_request = self._validate_client_connection_request(connection_id=connection_request_id)
+            if valid_connection_request:
                 database_client_connection = self._client_connection_requests.pop(connection_request_id)
-                self.sys_log.info(
-                    f"{self.name}: DatabaseClient connection to {server_ip_address} authorised."
-                    f"Connection Request ID was {connection_request_id}."
-                )
-                self.connected = True
-                self._last_connection_successful = True
-                return database_client_connection
+                if isinstance(database_client_connection, DatabaseClientConnection):
+                    self.sys_log.info(
+                        f"{self.name}: Connection request ({connection_request_id}) to {server_ip_address} authorised. "
+                        f"Using connection id {database_client_connection}"
+                    )
+                    self.connected = True
+                    self._last_connection_successful = True
+                    return database_client_connection
+                else:
+                    self.sys_log.info(
+                        f"{self.name}: Connection request ({connection_request_id}) to {server_ip_address} declined"
+                    )
+                    self._last_connection_successful = False
+                    return None
             else:
-                self.sys_log.warning(
-                    f"{self.name}: DatabaseClient connection to {server_ip_address} declined."
-                    f"Connection Request ID was {connection_request_id}."
+                self.sys_log.info(
+                    f"{self.name}: Connection request ({connection_request_id}) to {server_ip_address} declined "
+                    f"due to unknown client-side connection request id"
                 )
-                self._last_connection_successful = False
                 return None
+
         payload = {"type": "connect_request", "password": password, "connection_request_id": connection_request_id}
         software_manager: SoftwareManager = self.software_manager
         software_manager.send_payload_to_session_manager(
@@ -300,9 +313,14 @@ class DatabaseClient(Application, identifier="DatabaseClient"):
         """
         if not self._can_perform_action():
             return None
+
         connection_request_id = str(uuid4())
         self._client_connection_requests[connection_request_id] = None
 
+        self.sys_log.info(
+            f"{self.name}: Sending new connection request ({connection_request_id}) to {self.server_ip_address}"
+        )
+
         return self._connect(
             server_ip_address=self.server_ip_address,
             password=self.server_password,

src/primaite/simulator/system/core/software_manager.py

@@ -4,6 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING, Union
 
 from prettytable import MARKDOWN, PrettyTable
 
+from primaite.simulator.core import RequestType
 from primaite.simulator.file_system.file_system import FileSystem
 from primaite.simulator.network.transmission.data_link_layer import Frame
 from primaite.simulator.network.transmission.network_layer import IPProtocol
@@ -20,9 +21,7 @@ if TYPE_CHECKING:
     from primaite.simulator.system.services.arp.arp import ARP
     from primaite.simulator.system.services.icmp.icmp import ICMP
 
-from typing import Type, TypeVar
-
-IOSoftwareClass = TypeVar("IOSoftwareClass", bound=IOSoftware)
+from typing import Type
 
 
 class SoftwareManager:
@@ -51,7 +50,7 @@ class SoftwareManager:
         self.node = parent_node
         self.session_manager = session_manager
         self.software: Dict[str, Union[Service, Application]] = {}
-        self._software_class_to_name_map: Dict[Type[IOSoftwareClass], str] = {}
+        self._software_class_to_name_map: Dict[Type[IOSoftware], str] = {}
         self.port_protocol_mapping: Dict[Tuple[Port, IPProtocol], Union[Service, Application]] = {}
         self.sys_log: SysLog = sys_log
         self.file_system: FileSystem = file_system
@@ -104,33 +103,38 @@ class SoftwareManager:
                 return True
         return False
 
-    def install(self, software_class: Type[IOSoftwareClass]):
+    def install(self, software_class: Type[IOSoftware], **install_kwargs):
         """
         Install an Application or Service.
 
         :param software_class: The software class.
         """
-        # TODO: Software manager and node itself both have an install method. Need to refactor to have more logical
-        # separation of concerns.
         if software_class in self._software_class_to_name_map:
             self.sys_log.warning(f"Cannot install {software_class} as it is already installed")
             return
         software = software_class(
-            software_manager=self, sys_log=self.sys_log, file_system=self.file_system, dns_server=self.dns_server
+            software_manager=self,
+            sys_log=self.sys_log,
+            file_system=self.file_system,
+            dns_server=self.dns_server,
+            **install_kwargs,
         )
+        software.parent = self.node
         if isinstance(software, Application):
-            software.install()
+            self.node.applications[software.uuid] = software
+            self.node._application_request_manager.add_request(
+                software.name, RequestType(func=software._request_manager)
+            )
+        elif isinstance(software, Service):
+            self.node.services[software.uuid] = software
+            self.node._service_request_manager.add_request(software.name, RequestType(func=software._request_manager))
+        software.install()
         software.software_manager = self
         self.software[software.name] = software
         self.port_protocol_mapping[(software.port, software.protocol)] = software
         if isinstance(software, Application):
             software.operating_state = ApplicationOperatingState.CLOSED
-
-        # add the software to the node's registry after it has been fully initialized
-        if isinstance(software, Service):
-            self.node.install_service(software)
-        elif isinstance(software, Application):
-            self.node.install_application(software)
+        self.node.sys_log.info(f"Installed {software.name}")
 
     def uninstall(self, software_name: str):
         """
@@ -138,25 +142,31 @@ class SoftwareManager:
 
         :param software_name: The software name.
         """
-        if software_name in self.software:
-            self.software[software_name].uninstall()
-            software = self.software.pop(software_name)  # noqa
-            if isinstance(software, Application):
-                self.node.uninstall_application(software)
-            elif isinstance(software, Service):
-                self.node.uninstall_service(software)
-            for key, value in self.port_protocol_mapping.items():
-                if value.name == software_name:
-                    self.port_protocol_mapping.pop(key)
-                    break
-            for key, value in self._software_class_to_name_map.items():
-                if value == software_name:
-                    self._software_class_to_name_map.pop(key)
-                    break
-            del software
-            self.sys_log.info(f"Uninstalled {software_name}")
+        if software_name not in self.software:
+            self.sys_log.error(f"Cannot uninstall {software_name} as it is not installed")
             return
-        self.sys_log.error(f"Cannot uninstall {software_name} as it is not installed")
+
+        self.software[software_name].uninstall()
+        software = self.software.pop(software_name)  # noqa
+        if isinstance(software, Application):
+            self.node.applications.pop(software.uuid)
+            self.node._application_request_manager.remove_request(software.name)
+        elif isinstance(software, Service):
+            self.node.services.pop(software.uuid)
+            software.uninstall()
+            self.node._service_request_manager.remove_request(software.name)
+        software.parent = None
+        for key, value in self.port_protocol_mapping.items():
+            if value.name == software_name:
+                self.port_protocol_mapping.pop(key)
+                break
+        for key, value in self._software_class_to_name_map.items():
+            if value == software_name:
+                self._software_class_to_name_map.pop(key)
+                break
+        del software
+        self.sys_log.info(f"Uninstalled {software_name}")
+        return
 
     def send_internal_payload(self, target_software: str, payload: Any):
         """

src/primaite/simulator/system/services/access/__init__.py

@@ -0,0 +1 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK

src/primaite/simulator/system/services/access/user_manager.py

@@ -0,0 +1 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK

src/primaite/simulator/system/services/access/user_session_manager.py

@@ -0,0 +1 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK

src/primaite/simulator/system/services/database/database_service.py

@@ -191,12 +191,16 @@ class DatabaseService(Service):
         :return: Response to connection request containing success info.
         :rtype: Dict[str, Union[int, Dict[str, bool]]]
         """
+        self.sys_log.info(f"{self.name}: Processing new connection request ({connection_request_id}) from {src_ip}")
         status_code = 500  # Default internal server error
         connection_id = None
         if self.operating_state == ServiceOperatingState.RUNNING:
             status_code = 503  # service unavailable
             if self.health_state_actual == SoftwareHealthState.OVERWHELMED:
-                self.sys_log.error(f"{self.name}: Connect request for {src_ip=} declined. Service is at capacity.")
+                self.sys_log.info(
+                    f"{self.name}: Connection request ({connection_request_id}) from {src_ip} declined, service is at "
+                    f"capacity."
+                )
             if self.health_state_actual in [
                 SoftwareHealthState.GOOD,
                 SoftwareHealthState.FIXING,
@@ -208,12 +212,16 @@ class DatabaseService(Service):
                     # try to create connection
                     if not self.add_connection(connection_id=connection_id, session_id=session_id):
                         status_code = 500
-                        self.sys_log.warning(f"{self.name}: Connect request for {connection_id=} declined")
-                    else:
-                        self.sys_log.info(f"{self.name}: Connect request for {connection_id=} authorised")
+                        self.sys_log.info(
+                            f"{self.name}: Connection request ({connection_request_id}) from {src_ip} declined, "
+                            f"returning status code 500"
+                        )
                 else:
                     status_code = 401  # Unauthorised
-                    self.sys_log.warning(f"{self.name}: Connect request for {connection_id=} declined")
+                    self.sys_log.info(
+                        f"{self.name}: Connection request ({connection_request_id}) from {src_ip} unauthorised "
+                        f"(incorrect password), returning status code 401"
+                    )
         else:
             status_code = 404  # service not found
         return {

src/primaite/simulator/system/services/terminal/__init__.py

@@ -0,0 +1 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK

src/primaite/simulator/system/services/terminal/terminal.py

@@ -0,0 +1,523 @@
+# © Crown-owned copyright 2024, Defence Science and Technology Laboratory UK
+from __future__ import annotations
+
+from abc import abstractmethod
+from datetime import datetime
+from ipaddress import IPv4Address
+from typing import Any, Dict, List, Optional, Union
+from uuid import uuid4
+
+from pydantic import BaseModel
+
+from primaite.interface.request import RequestFormat, RequestResponse
+from primaite.simulator.core import RequestManager, RequestType
+from primaite.simulator.network.protocols.ssh import (
+    SSHConnectionMessage,
+    SSHPacket,
+    SSHTransportMessage,
+    SSHUserCredentials,
+)
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.core.software_manager import SoftwareManager
+from primaite.simulator.system.services.service import Service, ServiceOperatingState
+
+
+class TerminalClientConnection(BaseModel):
+    """
+    TerminalClientConnection Class.
+
+    This class is used to record current User Connections to the Terminal class.
+    """
+
+    parent_terminal: Terminal
+    """The parent Node that this connection was created on."""
+
+    session_id: str = None
+    """Session ID that connection is linked to"""
+
+    connection_uuid: str = None
+    """Connection UUID"""
+
+    connection_request_id: str = None
+    """Connection request ID"""
+
+    time: datetime = None
+    """Timestamp connection was created."""
+
+    ip_address: IPv4Address
+    """Source IP of Connection"""
+
+    is_active: bool = True
+    """Flag to state whether the connection is active or not"""
+
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}(connection_id='{self.connection_uuid}')"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    def __getitem__(self, key: Any) -> Any:
+        return getattr(self, key)
+
+    @property
+    def client(self) -> Optional[Terminal]:
+        """The Terminal that holds this connection."""
+        return self.parent_terminal
+
+    def disconnect(self) -> bool:
+        """Disconnect the session."""
+        return self.parent_terminal._disconnect(connection_uuid=self.connection_uuid)
+
+    @abstractmethod
+    def execute(self, command: Any) -> bool:
+        """Execute a given command."""
+        pass
+
+
+class LocalTerminalConnection(TerminalClientConnection):
+    """
+    LocalTerminalConnectionClass.
+
+    This class represents a local terminal when connected.
+    """
+
+    ip_address: str = "Local Connection"
+
+    def execute(self, command: Any) -> Optional[RequestResponse]:
+        """Execute a given command on local Terminal."""
+        if self.parent_terminal.operating_state != ServiceOperatingState.RUNNING:
+            self.parent_terminal.sys_log.warning("Cannot process command as system not running")
+            return None
+        if not self.is_active:
+            self.parent_terminal.sys_log.warning("Connection inactive, cannot execute")
+            return None
+        return self.parent_terminal.execute(command, connection_id=self.connection_uuid)
+
+
+class RemoteTerminalConnection(TerminalClientConnection):
+    """
+    RemoteTerminalConnection Class.
+
+    This class acts as broker between the terminal and remote.
+
+    """
+
+    def execute(self, command: Any) -> bool:
+        """Execute a given command on the remote Terminal."""
+        if self.parent_terminal.operating_state != ServiceOperatingState.RUNNING:
+            self.parent_terminal.sys_log.warning("Cannot process command as system not running")
+            return False
+        if not self.is_active:
+            self.parent_terminal.sys_log.warning("Connection inactive, cannot execute")
+            return False
+        # Send command to remote terminal to process.
+
+        transport_message: SSHTransportMessage = SSHTransportMessage.SSH_MSG_SERVICE_REQUEST
+        connection_message: SSHConnectionMessage = SSHConnectionMessage.SSH_MSG_CHANNEL_DATA
+
+        payload: SSHPacket = SSHPacket(
+            transport_message=transport_message,
+            connection_message=connection_message,
+            connection_request_uuid=self.connection_request_id,
+            connection_uuid=self.connection_uuid,
+            ssh_command=command,
+        )
+
+        return self.parent_terminal.send(payload=payload, session_id=self.session_id)
+
+
+class Terminal(Service):
+    """Class used to simulate a generic terminal service. Can be interacted with by other terminals via SSH."""
+
+    _client_connection_requests: Dict[str, Optional[Union[str, TerminalClientConnection]]] = {}
+
+    def __init__(self, **kwargs):
+        kwargs["name"] = "Terminal"
+        kwargs["port"] = Port.SSH
+        kwargs["protocol"] = IPProtocol.TCP
+        super().__init__(**kwargs)
+
+    def describe_state(self) -> Dict:
+        """
+        Produce a dictionary describing the current state of this object.
+
+        Please see :py:meth:`primaite.simulator.core.SimComponent.describe_state` for a more detailed explanation.
+
+        :return: Current state of this object and child objects.
+        :rtype: Dict
+        """
+        state = super().describe_state()
+        return state
+
+    def show(self, markdown: bool = False):
+        """
+        Display the remote connections to this terminal instance in tabular format.
+
+        :param markdown: Whether to display the table in Markdown format or not. Default is `False`.
+        """
+        self.show_connections(markdown=markdown)
+
+    def _init_request_manager(self) -> RequestManager:
+        """Initialise Request manager."""
+        rm = super()._init_request_manager()
+        rm.add_request(
+            "send",
+            request_type=RequestType(func=lambda request, context: RequestResponse.from_bool(self.send())),
+        )
+
+        def _login(request: RequestFormat, context: Dict) -> RequestResponse:
+            login = self._process_local_login(username=request[0], password=request[1])
+            if login:
+                return RequestResponse(status="success", data={})
+            else:
+                return RequestResponse(status="failure", data={})
+
+        def _remote_login(request: RequestFormat, context: Dict) -> RequestResponse:
+            login = self._send_remote_login(username=request[0], password=request[1], ip_address=request[2])
+            if login:
+                return RequestResponse(status="success", data={})
+            else:
+                return RequestResponse(status="failure", data={})
+
+        def _execute_request(request: RequestFormat, context: Dict) -> RequestResponse:
+            """Execute an instruction."""
+            command: str = request[0]
+            connection_id: str = request[1]
+            self.execute(command, connection_id=connection_id)
+            return RequestResponse(status="success", data={})
+
+        def _logoff(request: RequestFormat, context: Dict) -> RequestResponse:
+            """Logoff from connection."""
+            connection_uuid = request[0]
+            # TODO: Uncomment this when UserSessionManager merged.
+            # self.parent.UserSessionManager.logoff(connection_uuid)
+            self._disconnect(connection_uuid)
+
+            return RequestResponse(status="success", data={})
+
+        rm.add_request(
+            "Login",
+            request_type=RequestType(func=_login),
+        )
+
+        rm.add_request(
+            "Remote Login",
+            request_type=RequestType(func=_remote_login),
+        )
+
+        rm.add_request(
+            "Execute",
+            request_type=RequestType(func=_execute_request),
+        )
+
+        rm.add_request("Logoff", request_type=RequestType(func=_logoff))
+
+        return rm
+
+    def execute(self, command: List[Any], connection_id: str) -> Optional[RequestResponse]:
+        """Execute a passed ssh command via the request manager."""
+        valid_connection = self._check_client_connection(connection_id=connection_id)
+        if valid_connection:
+            return self.parent.apply_request(command)
+        else:
+            self.sys_log.error("Invalid connection ID provided")
+            return None
+
+    def _create_local_connection(self, connection_uuid: str, session_id: str) -> TerminalClientConnection:
+        """Create a new connection object and amend to list of active connections.
+
+        :param connection_uuid: Connection ID of the new local connection
+        :param session_id: Session ID of the new local connection
+        :return: TerminalClientConnection object
+        """
+        new_connection = LocalTerminalConnection(
+            parent_terminal=self,
+            connection_uuid=connection_uuid,
+            session_id=session_id,
+            time=datetime.now(),
+        )
+        self._connections[connection_uuid] = new_connection
+        self._client_connection_requests[connection_uuid] = new_connection
+
+        return new_connection
+
+    def login(
+        self, username: str, password: str, ip_address: Optional[IPv4Address] = None
+    ) -> Optional[TerminalClientConnection]:
+        """Login to the terminal. Will attempt a remote login if ip_address is given, else local.
+
+        :param: username: Username used to connect to the remote node.
+        :type: username: str
+
+        :param: password: Password used to connect to the remote node
+        :type: password: str
+
+        :param: ip_address: Target Node IP address for login attempt. If None, login is assumed local.
+        :type: ip_address: Optional[IPv4Address]
+        """
+        if self.operating_state != ServiceOperatingState.RUNNING:
+            self.sys_log.warning("Cannot login as service is not running.")
+            return None
+        connection_request_id = str(uuid4())
+        self._client_connection_requests[connection_request_id] = None
+        if ip_address:
+            # Assuming that if IP is passed we are connecting to remote
+            return self._send_remote_login(
+                username=username, password=password, ip_address=ip_address, connection_request_id=connection_request_id
+            )
+        else:
+            return self._process_local_login(username=username, password=password)
+
+    def _process_local_login(self, username: str, password: str) -> Optional[TerminalClientConnection]:
+        """Local session login to terminal.
+
+        :param username: Username for login.
+        :param password: Password for login.
+        :return: boolean, True if successful, else False
+        """
+        # TODO: Un-comment this when UserSessionManager is merged.
+        # connection_uuid = self.parent.UserSessionManager.login(username=username, password=password)
+        connection_uuid = str(uuid4())
+        if connection_uuid:
+            self.sys_log.info(f"Login request authorised, connection uuid: {connection_uuid}")
+            # Add new local session to list of connections and return
+            return self._create_local_connection(connection_uuid=connection_uuid, session_id="Local_Connection")
+        else:
+            self.sys_log.warning("Login failed, incorrect Username or Password")
+            return None
+
+    def _validate_client_connection_request(self, connection_id: str) -> bool:
+        """Check that client_connection_id is valid."""
+        return True if connection_id in self._client_connection_requests else False
+
+    def _check_client_connection(self, connection_id: str) -> bool:
+        """Check that client_connection_id is valid."""
+        return True if connection_id in self._connections else False
+
+    def _send_remote_login(
+        self,
+        username: str,
+        password: str,
+        ip_address: IPv4Address,
+        connection_request_id: str,
+        is_reattempt: bool = False,
+    ) -> Optional[RemoteTerminalConnection]:
+        """Send a remote login attempt and connect to Node.
+
+        :param: username: Username used to connect to the remote node.
+        :type: username: str
+
+        :param: password: Password used to connect to the remote node
+        :type: password: str
+
+        :param: ip_address: Target Node IP address for login attempt.
+        :type: ip_address: IPv4Address
+
+        :param: connection_request_id: Connection Request ID
+        :type: connection_request_id: str
+
+        :param: is_reattempt: True if the request has been reattempted. Default False.
+        :type: is_reattempt: Optional[bool]
+
+        :return: RemoteTerminalConnection: Connection Object for sending further commands if successful, else False.
+
+        """
+        self.sys_log.info(f"Sending Remote login attempt to {ip_address}. Connection_id is {connection_request_id}")
+        if is_reattempt:
+            valid_connection_request = self._validate_client_connection_request(connection_id=connection_request_id)
+            if valid_connection_request:
+                remote_terminal_connection = self._client_connection_requests.pop(connection_request_id)
+                if isinstance(remote_terminal_connection, RemoteTerminalConnection):
+                    self.sys_log.info(f"{self.name}: Remote Connection to {ip_address} authorised.")
+                    return remote_terminal_connection
+                else:
+                    self.sys_log.warning(f"Connection request{connection_request_id} declined")
+                    return None
+            else:
+                self.sys_log.warning(f"{self.name}: Remote connection to {ip_address} declined.")
+                return None
+
+        transport_message: SSHTransportMessage = SSHTransportMessage.SSH_MSG_USERAUTH_REQUEST
+        connection_message: SSHConnectionMessage = SSHConnectionMessage.SSH_MSG_CHANNEL_DATA
+        user_details: SSHUserCredentials = SSHUserCredentials(username=username, password=password)
+
+        payload_contents = {
+            "type": "login_request",
+            "username": username,
+            "password": password,
+            "connection_request_id": connection_request_id,
+        }
+
+        payload: SSHPacket = SSHPacket(
+            payload=payload_contents,
+            transport_message=transport_message,
+            connection_message=connection_message,
+            user_account=user_details,
+            connection_request_uuid=connection_request_id,
+        )
+
+        software_manager: SoftwareManager = self.software_manager
+        software_manager.send_payload_to_session_manager(
+            payload=payload, dest_ip_address=ip_address, dest_port=self.port
+        )
+        return self._send_remote_login(
+            username=username,
+            password=password,
+            ip_address=ip_address,
+            is_reattempt=True,
+            connection_request_id=connection_request_id,
+        )
+
+    def _create_remote_connection(
+        self, connection_id: str, connection_request_id: str, session_id: str, source_ip: str
+    ) -> None:
+        """Create a new TerminalClientConnection Object.
+
+        :param: connection_request_id: Connection Request ID
+        :type: connection_request_id: str
+
+        :param: session_id: Session ID of connection.
+        :type: session_id: str
+        """
+        client_connection = RemoteTerminalConnection(
+            parent_terminal=self,
+            session_id=session_id,
+            connection_uuid=connection_id,
+            ip_address=source_ip,
+            connection_request_id=connection_request_id,
+            time=datetime.now(),
+        )
+        self._connections[connection_id] = client_connection
+        self._client_connection_requests[connection_request_id] = client_connection
+
+    def receive(self, session_id: str, payload: Union[SSHPacket, Dict], **kwargs) -> bool:
+        """
+        Receive a payload from the Software Manager.
+
+        :param payload: A payload to receive.
+        :param session_id: The session id the payload relates to.
+        :return: True.
+        """
+        source_ip = kwargs["from_network_interface"].ip_address
+        self.sys_log.info(f"Received payload: {payload}. Source: {source_ip}")
+        if isinstance(payload, SSHPacket):
+            if payload.transport_message == SSHTransportMessage.SSH_MSG_USERAUTH_REQUEST:
+                # validate & add connection
+                # TODO: uncomment this as part of 2781
+                # connection_id = self.parent.UserSessionManager.login(username=username, password=password)
+                connection_id = str(uuid4())
+                if connection_id:
+                    connection_request_id = payload.connection_request_uuid
+                    username = payload.user_account.username
+                    password = payload.user_account.password
+                    print(f"Connection ID is: {connection_request_id}")
+                    self.sys_log.info(f"Connection authorised, session_id: {session_id}")
+                    self._create_remote_connection(
+                        connection_id=connection_id,
+                        connection_request_id=connection_request_id,
+                        session_id=session_id,
+                        source_ip=source_ip,
+                    )
+
+                    transport_message = SSHTransportMessage.SSH_MSG_USERAUTH_SUCCESS
+                    connection_message = SSHConnectionMessage.SSH_MSG_CHANNEL_DATA
+
+                    payload_contents = {
+                        "type": "login_success",
+                        "username": username,
+                        "password": password,
+                        "connection_request_id": connection_request_id,
+                        "connection_id": connection_id,
+                    }
+                    payload: SSHPacket = SSHPacket(
+                        payload=payload_contents,
+                        transport_message=transport_message,
+                        connection_message=connection_message,
+                        connection_request_uuid=connection_request_id,
+                        connection_uuid=connection_id,
+                    )
+
+                    software_manager: SoftwareManager = self.software_manager
+                    software_manager.send_payload_to_session_manager(
+                        payload=payload, dest_port=self.port, session_id=session_id
+                    )
+            elif payload.transport_message == SSHTransportMessage.SSH_MSG_USERAUTH_SUCCESS:
+                self.sys_log.info("Login Successful")
+                self._create_remote_connection(
+                    connection_id=payload.connection_uuid,
+                    connection_request_id=payload.connection_request_uuid,
+                    session_id=session_id,
+                    source_ip=source_ip,
+                )
+
+            elif payload.transport_message == SSHTransportMessage.SSH_MSG_SERVICE_REQUEST:
+                # Requesting a command to be executed
+                self.sys_log.info("Received command to execute")
+                command = payload.ssh_command
+                valid_connection = self._check_client_connection(payload.connection_uuid)
+                self.sys_log.info(f"Connection uuid is {valid_connection}")
+                if valid_connection:
+                    return self.execute(command, payload.connection_uuid)
+                else:
+                    self.sys_log.error(f"Connection UUID:{payload.connection_uuid} is not valid. Rejecting Command.")
+
+        if isinstance(payload, dict) and payload.get("type"):
+            if payload["type"] == "disconnect":
+                connection_id = payload["connection_id"]
+                valid_id = self._check_client_connection(connection_id)
+                if valid_id:
+                    self.sys_log.info(f"{self.name}: Received disconnect command for {connection_id=} from remote.")
+                    self._disconnect(payload["connection_id"])
+                else:
+                    self.sys_log.info("No Active connection held for received connection ID.")
+
+        return True
+
+    def _disconnect(self, connection_uuid: str) -> bool:
+        """Disconnect from the remote.
+
+        :param connection_uuid: Connection ID that we want to disconnect.
+        :return True if successful, False otherwise.
+        """
+        if not self._connections:
+            self.sys_log.warning("No remote connection present")
+            return False
+
+        connection = self._connections.pop(connection_uuid)
+        connection.is_active = False
+
+        if isinstance(connection, RemoteTerminalConnection):
+            # Send disconnect command via software manager
+            session_id = connection.session_id
+
+            software_manager: SoftwareManager = self.software_manager
+            software_manager.send_payload_to_session_manager(
+                payload={"type": "disconnect", "connection_id": connection_uuid},
+                dest_port=self.port,
+                session_id=session_id,
+            )
+            self.sys_log.info(f"{self.name}: Disconnected {connection_uuid}")
+            return True
+
+        elif isinstance(connection, LocalTerminalConnection):
+            # No further action needed
+            return True
+
+    def send(
+        self, payload: SSHPacket, dest_ip_address: Optional[IPv4Address] = None, session_id: Optional[str] = None
+    ) -> bool:
+        """
+        Send a payload out from the Terminal.
+
+        :param payload: The payload to be sent.
+        :param dest_up_address: The IP address of the payload destination.
+        """
+        if self.operating_state != ServiceOperatingState.RUNNING:
+            self.sys_log.warning(f"Cannot send commands when Operating state is {self.operating_state}!")
+            return False
+
+        self.sys_log.debug(f"Sending payload: {payload}")
+        return super().send(
+            payload=payload, dest_ip_address=dest_ip_address, dest_port=self.port, session_id=session_id
+        )

src/primaite/simulator/system/software.py

@@ -291,7 +291,7 @@ class IOSoftware(Software):
         """
         if self.software_manager and self.software_manager.node.operating_state != NodeOperatingState.ON:
             self.software_manager.node.sys_log.error(
-                f"{self.name} Error: {self.software_manager.node.hostname} is not online."
+                f"{self.name} Error: {self.software_manager.node.hostname} is not powered on."
             )
             return False
         return True
@@ -313,7 +313,7 @@ class IOSoftware(Software):
         # if over or at capacity, set to overwhelmed
         if len(self._connections) >= self.max_sessions:
             self.set_health_state(SoftwareHealthState.OVERWHELMED)
-            self.sys_log.warning(f"{self.name}: Connect request for {connection_id=} declined. Service is at capacity.")
+            self.sys_log.warning(f"{self.name}: Connection request ({connection_id}) declined. Service is at capacity.")
             return False
         else:
             # if service was previously overwhelmed, set to good because there is enough space for connections
@@ -330,11 +330,11 @@ class IOSoftware(Software):
                     "ip_address": session_details.with_ip_address if session_details else None,
                     "time": datetime.now(),
                 }
-                self.sys_log.info(f"{self.name}: Connect request for {connection_id=} authorised")
+                self.sys_log.info(f"{self.name}: Connection request ({connection_id}) authorised")
                 return True
             # connection with given id already exists
             self.sys_log.warning(
-                f"{self.name}: Connect request for {connection_id=} declined. Connection already exists."
+                f"{self.name}: Connection request ({connection_id}) declined. Connection already exists."
             )
             return False