#2459 back-sync b8 changes into core

src/primaite/simulator/__init__.py

@@ -14,6 +14,7 @@ class _SimOutput:
         )
         self.save_pcap_logs: bool = False
         self.save_sys_logs: bool = False
+        self.write_sys_log_to_terminal: bool = False
 
     @property
     def path(self) -> Path:

src/primaite/simulator/core.py

@@ -226,6 +226,15 @@ class SimComponent(BaseModel):
             return
         return self._request_manager(request, context)
 
+    def pre_timestep(self, timestep: int) -> None:
+        """
+        Apply any logic that needs to happen at the beginning of the timestep to ensure correct observations/rewards.
+
+        :param timestep: what's the current time
+        :type timestep: int
+        """
+        pass
+
     def apply_timestep(self, timestep: int) -> None:
         """
         Apply a timestep evolution to this component.

src/primaite/simulator/file_system/file.py

@@ -103,6 +103,10 @@ class File(FileSystemItemABC):
         """
         super().apply_timestep(timestep=timestep)
 
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+
         # reset the number of accesses to 0
         self.num_access = 0
 

src/primaite/simulator/file_system/file_system.py

@@ -427,15 +427,21 @@ class FileSystem(SimComponent):
         """Apply time step to FileSystem and its child folders and files."""
         super().apply_timestep(timestep=timestep)
 
+        # apply timestep to folders
+        for folder_id in self.folders:
+            self.folders[folder_id].apply_timestep(timestep=timestep)
+
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
         # reset number of file creations
         self.num_file_creations = 0
 
         # reset number of file deletions
         self.num_file_deletions = 0
 
-        # apply timestep to folders
-        for folder_id in self.folders:
-            self.folders[folder_id].apply_timestep(timestep=timestep)
+        for folder in self.folders.values():
+            folder.pre_timestep(timestep)
 
     ###############################################################
     # Agent actions

src/primaite/simulator/file_system/folder.py

@@ -128,6 +128,13 @@ class Folder(FileSystemItemABC):
         for file_id in self.files:
             self.files[file_id].apply_timestep(timestep=timestep)
 
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+
+        for file in self.files.values():
+            file.pre_timestep(timestep)
+
     def _scan_timestep(self) -> None:
         """Apply the scan action timestep."""
         if self.scan_countdown >= 0:

src/primaite/simulator/network/container.py

@@ -1,3 +1,4 @@
+from ipaddress import IPv4Address
 from typing import Any, Dict, List, Optional
 
 import matplotlib.pyplot as plt
@@ -86,6 +87,16 @@ class Network(SimComponent):
         for link_id in self.links:
             self.links[link_id].apply_timestep(timestep=timestep)
 
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+
+        for node in self.nodes.values():
+            node.pre_timestep(timestep)
+
+        for link in self.links.values():
+            link.pre_timestep(timestep)
+
     @property
     def router_nodes(self) -> List[Node]:
         """The Routers in the Network."""
@@ -163,10 +174,11 @@ class Network(SimComponent):
                 for node in nodes:
                     for i, port in node.network_interface.items():
                         if hasattr(port, "ip_address"):
-                            port_str = port.port_name if port.port_name else port.port_num
-                            table.add_row(
-                                [node.hostname, port_str, port.ip_address, port.subnet_mask, node.default_gateway]
-                            )
+                            if port.ip_address != IPv4Address("127.0.0.1"):
+                                port_str = port.port_name if port.port_name else port.port_num
+                                table.add_row(
+                                    [node.hostname, port_str, port.ip_address, port.subnet_mask, node.default_gateway]
+                                )
             print(table)
 
         if links:

src/primaite/simulator/network/creation.py

@@ -9,7 +9,7 @@ from primaite.simulator.network.transmission.network_layer import IPProtocol
 from primaite.simulator.network.transmission.transport_layer import Port
 
 
-def num_of_switches_required(num_nodes: int, max_switch_ports: int = 24) -> int:
+def num_of_switches_required(num_nodes: int, max_network_interface: int = 24) -> int:
     """
     Calculate the minimum number of network switches required to connect a given number of nodes.
 
@@ -18,7 +18,7 @@ def num_of_switches_required(num_nodes: int, max_switch_ports: int = 24) -> int:
     to accommodate all nodes under this constraint.
 
     :param num_nodes: The total number of nodes that need to be connected in the network.
-    :param max_switch_ports: The maximum number of ports available on each switch. Defaults to 24.
+    :param max_network_interface: The maximum number of ports available on each switch. Defaults to 24.
 
     :return: The minimum number of switches required to connect all PCs.
 
@@ -33,11 +33,11 @@ def num_of_switches_required(num_nodes: int, max_switch_ports: int = 24) -> int:
     3
     """
     # Reduce the effective number of switch ports by 1 to leave space for the router
-    effective_switch_ports = max_switch_ports - 1
+    effective_network_interface = max_network_interface - 1
 
     # Calculate the number of fully utilised switches and any additional switch for remaining PCs
-    full_switches = num_nodes // effective_switch_ports
-    extra_pcs = num_nodes % effective_switch_ports
+    full_switches = num_nodes // effective_network_interface
+    extra_pcs = num_nodes % effective_network_interface
 
     # Return the total number of switches required
     return full_switches + (1 if extra_pcs > 0 else 0)
@@ -77,7 +77,7 @@ def create_office_lan(
 
     # Calculate the required number of switches
     num_of_switches = num_of_switches_required(num_nodes=num_pcs)
-    effective_switch_ports = 23  # One port less for router connection
+    effective_network_interface = 23  # One port less for router connection
     if pcs_ip_block_start <= num_of_switches:
         raise ValueError(f"pcs_ip_block_start must be greater than the number of required switches {num_of_switches}")
 
@@ -116,7 +116,7 @@ def create_office_lan(
     # Add PCs to the LAN and connect them to switches
     for i in range(1, num_pcs + 1):
         # Add a new edge switch if the current one is full
-        if switch_port == effective_switch_ports:
+        if switch_port == effective_network_interface:
             switch_n += 1
             switch_port = 0
             switch = Switch(hostname=f"switch_edge_{switch_n}_{lan_name}", start_up_duration=0)

src/primaite/simulator/network/hardware/base.py

@@ -264,6 +264,9 @@ class NetworkInterface(SimComponent, ABC):
         """
         return f"Port {self.port_name if self.port_name else self.port_num}: {self.mac_address}"
 
+    def __hash__(self) -> int:
+        return hash(self.uuid)
+
     def apply_timestep(self, timestep: int) -> None:
         """
         Apply a timestep evolution to this component.
@@ -661,6 +664,10 @@ class Link(SimComponent):
     def apply_timestep(self, timestep: int) -> None:
         """Apply a timestep to the simulation."""
         super().apply_timestep(timestep)
+
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
         self.current_load = 0.0
 
 
@@ -895,6 +902,10 @@ class Node(SimComponent):
             from primaite.simulator.system.applications.web_browser import WebBrowser
 
             return WebBrowser
+        elif application_class_str == "RansomwareScript":
+            from primaite.simulator.system.applications.red_applications.ransomware_script import RansomwareScript
+
+            return RansomwareScript
         else:
             return 0
 
@@ -965,12 +976,15 @@ class Node(SimComponent):
         table.align = "l"
         table.title = f"{self.hostname} Network Interface Cards"
         for port, network_interface in self.network_interface.items():
+            ip_address = ""
+            if hasattr(network_interface, "ip_address"):
+                ip_address = f"{network_interface.ip_address}/{network_interface.ip_network.prefixlen}"
             table.add_row(
                 [
                     port,
                     network_interface.__class__.__name__,
                     network_interface.mac_address,
-                    f"{network_interface.ip_address}/{network_interface.ip_network.prefixlen}",
+                    ip_address,
                     network_interface.speed,
                     "Enabled" if network_interface.enabled else "Disabled",
                 ]
@@ -1071,6 +1085,23 @@ class Node(SimComponent):
 
             self.file_system.apply_timestep(timestep=timestep)
 
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+        for network_interface in self.network_interfaces.values():
+            network_interface.pre_timestep(timestep=timestep)
+
+        for process_id in self.processes:
+            self.processes[process_id].pre_timestep(timestep=timestep)
+
+        for service_id in self.services:
+            self.services[service_id].pre_timestep(timestep=timestep)
+
+        for application_id in self.applications:
+            self.applications[application_id].pre_timestep(timestep=timestep)
+
+        self.file_system.pre_timestep(timestep=timestep)
+
     def scan(self) -> bool:
         """
         Scan the node and all the items within it.
@@ -1341,6 +1372,8 @@ class Node(SimComponent):
                 application_instance.configure(target_ip_address=IPv4Address(ip_address))
             elif application_instance.name == "DataManipulationBot":
                 application_instance.configure(server_ip_address=IPv4Address(ip_address))
+            elif application_instance.name == "RansomwareScript":
+                application_instance.configure(server_ip_address=IPv4Address(ip_address))
             else:
                 pass
 

src/primaite/simulator/network/hardware/nodes/network/firewall.py

@@ -599,7 +599,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 
@@ -612,7 +614,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 
@@ -625,7 +629,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 
@@ -638,7 +644,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 
@@ -651,7 +659,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 
@@ -664,7 +674,9 @@ class Firewall(Router):
                         dst_port=None if not (p := r_cfg.get("dst_port")) else Port[p],
                         protocol=None if not (p := r_cfg.get("protocol")) else IPProtocol[p],
                         src_ip_address=r_cfg.get("src_ip"),
+                        src_wildcard_mask=r_cfg.get("src_wildcard_mask"),
                         dst_ip_address=r_cfg.get("dst_ip"),
+                        dst_wildcard_mask=r_cfg.get("dst_wildcard_mask"),
                         position=r_num,
                     )
 

src/primaite/simulator/network/hardware/nodes/network/router.py

@@ -322,10 +322,12 @@ class AccessControlList(SimComponent):
                         action=ACLAction[request[0]],
                         protocol=None if request[1] == "ALL" else IPProtocol[request[1]],
                         src_ip_address=None if request[2] == "ALL" else IPv4Address(request[2]),
-                        src_port=None if request[3] == "ALL" else Port[request[3]],
-                        dst_ip_address=None if request[4] == "ALL" else IPv4Address(request[4]),
-                        dst_port=None if request[5] == "ALL" else Port[request[5]],
-                        position=int(request[6]),
+                        src_wildcard_mask=None if request[3] == "NONE" else IPv4Address(request[3]),
+                        src_port=None if request[4] == "ALL" else Port[request[4]],
+                        dst_ip_address=None if request[5] == "ALL" else IPv4Address(request[5]),
+                        dst_wildcard_mask=None if request[6] == "NONE" else IPv4Address(request[6]),
+                        dst_port=None if request[7] == "ALL" else Port[request[7]],
+                        position=int(request[8]),
                     )
                 )
             ),
@@ -772,6 +774,13 @@ class RouterARP(ARP):
                     is_reattempt=True,
                     is_default_route_attempt=is_default_route_attempt,
                 )
+            elif route and route == self.router.route_table.default_route:
+                self.send_arp_request(self.router.route_table.default_route.next_hop_ip_address)
+                return self._get_arp_cache_mac_address(
+                    ip_address=self.router.route_table.default_route.next_hop_ip_address,
+                    is_reattempt=True,
+                    is_default_route_attempt=True,
+                )
         else:
             if self.router.route_table.default_route:
                 if not is_default_route_attempt:
@@ -822,6 +831,12 @@ class RouterARP(ARP):
                 return network_interface
 
         if not is_reattempt:
+            if self.router.ip_is_in_router_interface_subnet(ip_address):
+                self.send_arp_request(ip_address)
+                return self._get_arp_cache_network_interface(
+                    ip_address=ip_address, is_reattempt=True, is_default_route_attempt=is_default_route_attempt
+                )
+
             route = self.router.route_table.find_best_route(ip_address)
             if route and route != self.router.route_table.default_route:
                 self.send_arp_request(route.next_hop_ip_address)
@@ -830,6 +845,13 @@ class RouterARP(ARP):
                     is_reattempt=True,
                     is_default_route_attempt=is_default_route_attempt,
                 )
+            elif route and route == self.router.route_table.default_route:
+                self.send_arp_request(self.router.route_table.default_route.next_hop_ip_address)
+                return self._get_arp_cache_network_interface(
+                    ip_address=self.router.route_table.default_route.next_hop_ip_address,
+                    is_reattempt=True,
+                    is_default_route_attempt=True,
+                )
         else:
             if self.router.route_table.default_route:
                 if not is_default_route_attempt:
@@ -1460,6 +1482,8 @@ class Router(NetworkNode):
             frame.ethernet.src_mac_addr = network_interface.mac_address
             frame.ethernet.dst_mac_addr = target_mac
             network_interface.send_frame(frame)
+        else:
+            self.sys_log.error(f"Frame dropped as there is no route to {frame.ip.dst_ip_address}")
 
     def configure_port(self, port: int, ip_address: Union[IPv4Address, str], subnet_mask: Union[IPv4Address, str]):
         """
@@ -1540,6 +1564,13 @@ class Router(NetworkNode):
               - protocol (str, optional): the named IP protocol such as ICMP, TCP, or UDP
               - src_ip_address (str, optional): IP address octet written in base 10
               - dst_ip_address (str, optional): IP address octet written in base 10
+          - routes (list[dict]): List of route dicts with values:
+            - address (str): The destination address of the route.
+            - subnet_mask (str): The subnet mask of the route.
+            - next_hop_ip_address (str): The next hop IP for the route.
+            - metric (int): The metric of the route. Optional.
+          - default_route:
+            - next_hop_ip_address (str): The next hop IP for the route.
 
         Example config:
         ```
@@ -1550,6 +1581,10 @@ class Router(NetworkNode):
                 1: {
                     'ip_address' : '192.168.1.1',
                     'subnet_mask' : '255.255.255.0',
+                },
+                2: {
+                    'ip_address' : '192.168.0.1',
+                    'subnet_mask' : '255.255.255.252',
                 }
             },
             'acl' : {
@@ -1557,6 +1592,10 @@ class Router(NetworkNode):
                 22: {'action': 'PERMIT', 'src_port': 'ARP', 'dst_port': 'ARP'},
                 23: {'action': 'PERMIT', 'protocol': 'ICMP'},
             },
+            'routes' : [
+                {'address': '192.168.0.0', 'subnet_mask': '255.255.255.0', 'next_hop_ip_address': '192.168.1.2'}
+            ],
+            'default_route': {'next_hop_ip_address': '192.168.0.2'}
         }
         ```
 
@@ -1600,4 +1639,8 @@ class Router(NetworkNode):
                     next_hop_ip_address=IPv4Address(route.get("next_hop_ip_address")),
                     metric=float(route.get("metric", 0)),
                 )
+        if "default_route" in cfg:
+            next_hop_ip_address = cfg["default_route"].get("next_hop_ip_address", None)
+            if next_hop_ip_address:
+                router.route_table.set_default_route_next_hop_ip_address(next_hop_ip_address)
         return router

src/primaite/simulator/network/hardware/nodes/network/switch.py

@@ -100,13 +100,8 @@ class Switch(NetworkNode):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        if not self.network_interface:
-            self.network_interface = {i: SwitchPort() for i in range(1, self.num_ports + 1)}
-        for port_num, port in self.network_interface.items():
-            port._connected_node = self
-            port.port_num = port_num
-            port.parent = self
-            port.port_num = port_num
+        for i in range(1, self.num_ports + 1):
+            self.connect_nic(SwitchPort())
 
     def show(self, markdown: bool = False):
         """

src/primaite/simulator/network/transmission/data_link_layer.py

@@ -8,7 +8,7 @@ from primaite.simulator.network.protocols.icmp import ICMPPacket
 from primaite.simulator.network.protocols.packet import DataPacket
 from primaite.simulator.network.transmission.network_layer import IPPacket, IPProtocol
 from primaite.simulator.network.transmission.primaite_layer import PrimaiteHeader
-from primaite.simulator.network.transmission.transport_layer import TCPHeader, UDPHeader
+from primaite.simulator.network.transmission.transport_layer import Port, TCPHeader, UDPHeader
 from primaite.simulator.network.utils import convert_bytes_to_megabits
 
 _LOGGER = getLogger(__name__)
@@ -141,3 +141,37 @@ class Frame(BaseModel):
     def size_Mbits(self) -> float:  # noqa - Keep it as MBits as this is how they're expressed
         """The daa transfer size of the Frame in Mbits."""
         return convert_bytes_to_megabits(self.size)
+
+    @property
+    def is_broadcast(self) -> bool:
+        """
+        Determines if the Frame is a broadcast frame.
+
+        A Frame is considered a broadcast frame if the destination MAC address is set to the broadcast address
+        "ff:ff:ff:ff:ff:ff".
+
+        :return: True if the destination MAC address is a broadcast address, otherwise False.
+        """
+        return self.ethernet.dst_mac_addr.lower() == "ff:ff:ff:ff:ff:ff"
+
+    @property
+    def is_arp(self) -> bool:
+        """
+        Checks if the Frame is an ARP (Address Resolution Protocol) packet.
+
+        This is determined by checking if the destination port of the TCP header is equal to the ARP port.
+
+        :return: True if the Frame is an ARP packet, otherwise False.
+        """
+        return self.udp.dst_port == Port.ARP
+
+    @property
+    def is_icmp(self) -> bool:
+        """
+        Determines if the Frame is an ICMP (Internet Control Message Protocol) packet.
+
+        This check is performed by verifying if the 'icmp' attribute of the Frame instance is present (not None).
+
+        :return: True if the Frame is an ICMP packet (i.e., has an ICMP header), otherwise False.
+        """
+        return self.icmp is not None

src/primaite/simulator/network/transmission/transport_layer.py

@@ -11,6 +11,9 @@ class Port(Enum):
     .. _List of Ports:
     """
 
+    UNUSED = -1
+    "An unused port stub."
+
     NONE = 0
     "Place holder for a non-port."
     WOL = 9

src/primaite/simulator/sim_container.py

@@ -63,3 +63,8 @@ class Simulation(SimComponent):
         """Apply a timestep to the simulation."""
         super().apply_timestep(timestep)
         self.network.apply_timestep(timestep)
+
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+        self.network.pre_timestep(timestep)

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

@@ -80,7 +80,10 @@ class Application(IOSoftware):
         """
         super().apply_timestep(timestep=timestep)
 
-        self.num_executions = 0  # reset number of executions
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+        self.num_executions = 0
 
     def _can_perform_action(self) -> bool:
         """

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

@@ -31,6 +31,7 @@ class DatabaseClient(Application):
     """Keep track of connections that were established or verified during this step. Used for rewards."""
     last_query_response: Optional[Dict] = None
     """Keep track of the latest query response. Used to determine rewards."""
+    _server_connection_id: Optional[str] = None
 
     def __init__(self, **kwargs):
         kwargs["name"] = "DatabaseClient"
@@ -51,10 +52,9 @@ class DatabaseClient(Application):
     def execute(self) -> bool:
         """Execution definition for db client: perform a select query."""
         self.num_executions += 1  # trying to connect counts as an execution
-        if self.connections:
-            can_connect = self.check_connection(connection_id=list(self.connections.keys())[-1])
-        else:
-            can_connect = self.check_connection(connection_id=str(uuid4()))
+        if not self._server_connection_id:
+            self.connect()
+        can_connect = self.check_connection(connection_id=self._server_connection_id)
         self._last_connection_successful = can_connect
         return can_connect
 
@@ -80,17 +80,21 @@ class DatabaseClient(Application):
         self.server_password = server_password
         self.sys_log.info(f"{self.name}: Configured the {self.name} with {server_ip_address=}, {server_password=}.")
 
-    def connect(self, connection_id: Optional[str] = None) -> bool:
+    def connect(self) -> bool:
         """Connect to a Database Service."""
         if not self._can_perform_action():
             return False
 
-        if not connection_id:
-            connection_id = str(uuid4())
+        if not self._server_connection_id:
+            self._server_connection_id = str(uuid4())
 
         self.connected = self._connect(
-            server_ip_address=self.server_ip_address, password=self.server_password, connection_id=connection_id
+            server_ip_address=self.server_ip_address,
+            password=self.server_password,
+            connection_id=self._server_connection_id,
         )
+        if not self.connected:
+            self._server_connection_id = None
         return self.connected
 
     def check_connection(self, connection_id: str) -> bool:
@@ -125,7 +129,7 @@ class DatabaseClient(Application):
         :type: is_reattempt: Optional[bool]
         """
         if is_reattempt:
-            if self.connections.get(connection_id):
+            if self._server_connection_id:
                 self.sys_log.info(
                     f"{self.name} {connection_id=}: DatabaseClient connection to {server_ip_address} authorised"
                 )
@@ -149,31 +153,28 @@ class DatabaseClient(Application):
             server_ip_address=server_ip_address, password=password, connection_id=connection_id, is_reattempt=True
         )
 
-    def disconnect(self, connection_id: Optional[str] = None) -> bool:
+    def disconnect(self) -> bool:
         """Disconnect from the Database Service."""
         if not self._can_perform_action():
             self.sys_log.error(f"Unable to disconnect - {self.name} is {self.operating_state.name}")
             return False
 
         # if there are no connections - nothing to disconnect
-        if not len(self.connections):
+        if not self._server_connection_id:
             self.sys_log.error(f"Unable to disconnect - {self.name} has no active connections.")
             return False
 
         # if no connection provided, disconnect the first connection
-        if not connection_id:
-            connection_id = list(self.connections.keys())[0]
-
         software_manager: SoftwareManager = self.software_manager
         software_manager.send_payload_to_session_manager(
-            payload={"type": "disconnect", "connection_id": connection_id},
+            payload={"type": "disconnect", "connection_id": self._server_connection_id},
             dest_ip_address=self.server_ip_address,
             dest_port=self.port,
         )
-        self.remove_connection(connection_id=connection_id)
+        self.remove_connection(connection_id=self._server_connection_id)
 
         self.sys_log.info(
-            f"{self.name}: DatabaseClient disconnected connection {connection_id} from {self.server_ip_address}"
+            f"{self.name}: DatabaseClient disconnected {self._server_connection_id} from {self.server_ip_address}"
         )
         self.connected = False
 
@@ -224,18 +225,20 @@ class DatabaseClient(Application):
         # reset last query response
         self.last_query_response = None
 
-        if connection_id is None:
-            if self.connections:
-                connection_id = list(self.connections.keys())[-1]
-                # TODO: if the most recent connection dies, it should be automatically cleared.
-            else:
-                connection_id = str(uuid4())
+        connection_id: str
 
-        if not self.connections.get(connection_id):
-            if not self.connect(connection_id=connection_id):
-                return False
+        if not connection_id:
+            connection_id = self._server_connection_id
+
+        if not connection_id:
+            self.connect()
+            connection_id = self._server_connection_id
+
+        if not connection_id:
+            msg = "Cannot run sql query, could not establish connection with the server."
+            self.parent.sys_log(msg)
+            return False
 
-            # Initialise the tracker of this ID to False
         uuid = str(uuid4())
         self._query_success_tracker[uuid] = False
         return self._query(sql=sql, query_id=uuid, connection_id=connection_id)

src/primaite/simulator/system/applications/red_applications/ransomware_script.py

@@ -0,0 +1,316 @@
+from enum import IntEnum
+from ipaddress import IPv4Address
+from typing import Dict, Optional
+
+from primaite import getLogger
+from primaite.game.science import simulate_trial
+from primaite.interface.request import RequestResponse
+from primaite.simulator.core import RequestManager, RequestType
+from primaite.simulator.network.transmission.network_layer import IPProtocol
+from primaite.simulator.network.transmission.transport_layer import Port
+from primaite.simulator.system.applications.application import Application
+from primaite.simulator.system.applications.database_client import DatabaseClient
+
+_LOGGER = getLogger(__name__)
+
+
+class RansomwareAttackStage(IntEnum):
+    """
+    Enumeration representing different attack stages of the ransomware script.
+
+    This enumeration defines the various stages a data manipulation attack can be in during its lifecycle
+    in the simulation.
+    Each stage represents a specific phase in the attack process.
+    """
+
+    NOT_STARTED = 0
+    "Indicates that the attack has not started yet."
+    DOWNLOAD = 1
+    "Installing the Encryption Script - Testing"
+    INSTALL = 2
+    "The stage where logon procedures are simulated."
+    ACTIVATE = 3
+    "Operating Status Changes"
+    PROPAGATE = 4
+    "Represents the stage of performing a horizontal port scan on the target."
+    COMMAND_AND_CONTROL = 5
+    "Represents the stage of setting up a rely C2 Beacon (Not Implemented)"
+    PAYLOAD = 6
+    "Stage of actively attacking the target."
+    SUCCEEDED = 7
+    "Indicates the attack has been successfully completed."
+    FAILED = 8
+    "Signifies that the attack has failed."
+
+
+class RansomwareScript(Application):
+    """Ransomware Kill Chain - Designed to be used by the TAP001 Agent on the example layout Network.
+
+    :ivar payload: The attack stage query payload. (Default Corrupt)
+    :ivar target_scan_p_of_success: The probability of success for the target scan stage.
+    :ivar c2_beacon_p_of_success: The probability of success for the c2_beacon stage
+    :ivar ransomware_encrypt_p_of_success: The probability of success for the ransomware 'attack' (encrypt) stage.
+    :ivar repeat: Whether to repeat attacking once finished.
+    """
+
+    server_ip_address: Optional[IPv4Address] = None
+    """IP address of node which hosts the database."""
+    server_password: Optional[str] = None
+    """Password required to access the database."""
+    payload: Optional[str] = "ENCRYPT"
+    "Payload String for the payload stage"
+    target_scan_p_of_success: float = 0.9
+    "Probability of the target scan succeeding: Default 0.9"
+    c2_beacon_p_of_success: float = 0.9
+    "Probability of the c2 beacon setup stage succeeding: Default 0.9"
+    ransomware_encrypt_p_of_success: float = 0.9
+    "Probability of the ransomware attack succeeding: Default 0.9"
+    repeat: bool = False
+    "If true, the Denial of Service bot will keep performing the attack."
+    attack_stage: RansomwareAttackStage = RansomwareAttackStage.NOT_STARTED
+    "The ransomware attack stage. See RansomwareAttackStage Class"
+
+    def __init__(self, **kwargs):
+        kwargs["name"] = "RansomwareScript"
+        kwargs["port"] = Port.NONE
+        kwargs["protocol"] = IPProtocol.NONE
+
+        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
+
+    @property
+    def _host_db_client(self) -> DatabaseClient:
+        """Return the database client that is installed on the same machine as the Ransomware Script."""
+        db_client = self.software_manager.software.get("DatabaseClient")
+        if db_client is None:
+            _LOGGER.info(f"{self.__class__.__name__} cannot find a database client on its host.")
+        return db_client
+
+    def _init_request_manager(self) -> RequestManager:
+        """
+        Initialise the request manager.
+
+        More information in user guide and docstring for SimComponent._init_request_manager.
+        """
+        rm = super()._init_request_manager()
+        rm.add_request(
+            name="execute",
+            request_type=RequestType(func=lambda request, context: RequestResponse.from_bool(self.attack())),
+        )
+        return rm
+
+    def _activate(self):
+        """
+        Simulate the install process as the initial stage of the attack.
+
+        Advances the attack stage to 'ACTIVATE' attack state.
+        """
+        if self.attack_stage == RansomwareAttackStage.INSTALL:
+            self.sys_log.info(f"{self.name}: Activated!")
+            self.attack_stage = RansomwareAttackStage.ACTIVATE
+
+    def apply_timestep(self, timestep: int) -> None:
+        """
+        Apply a timestep to the bot, triggering the application loop.
+
+        :param timestep: The timestep value to update the bot's state.
+        """
+        pass
+
+    def run(self) -> bool:
+        """Calls the parent classes execute method before starting the application loop."""
+        super().run()
+        return True
+
+    def _application_loop(self) -> bool:
+        """
+        The main application loop of the script, handling the attack process.
+
+        This is the core loop where the bot sequentially goes through the stages of the attack.
+        """
+        if not self._can_perform_action():
+            return False
+        if self.server_ip_address and self.payload:
+            self.sys_log.info(f"{self.name}: Running")
+            self.attack_stage = RansomwareAttackStage.NOT_STARTED
+            self._local_download()
+            self._install()
+            self._activate()
+            self._perform_target_scan()
+            self._setup_beacon()
+            self._perform_ransomware_encrypt()
+
+            if self.repeat and self.attack_stage in (
+                RansomwareAttackStage.SUCCEEDED,
+                RansomwareAttackStage.FAILED,
+            ):
+                self.attack_stage = RansomwareAttackStage.NOT_STARTED
+            return True
+        else:
+            self.sys_log.error(f"{self.name}: Failed to start as it requires both a target_ip_address and payload.")
+            return False
+
+    def configure(
+        self,
+        server_ip_address: IPv4Address,
+        server_password: Optional[str] = None,
+        payload: Optional[str] = None,
+        target_scan_p_of_success: Optional[float] = None,
+        c2_beacon_p_of_success: Optional[float] = None,
+        ransomware_encrypt_p_of_success: Optional[float] = None,
+        repeat: bool = True,
+    ):
+        """
+        Configure the Ransomware Script to communicate with a DatabaseService.
+
+        :param server_ip_address: The IP address of the Node the DatabaseService is on.
+        :param server_password: The password on the DatabaseService.
+        :param payload: The attack stage query (Encrypt / Delete)
+        :param target_scan_p_of_success: The probability of success for the target scan stage.
+        :param c2_beacon_p_of_success: The probability of success for the c2_beacon stage
+        :param ransomware_encrypt_p_of_success: The probability of success for the ransomware 'attack' (encrypt) stage.
+        :param repeat: Whether to repeat attacking once finished.
+        """
+        if server_ip_address:
+            self.server_ip_address = server_ip_address
+        if server_password:
+            self.server_password = server_password
+        if payload:
+            self.payload = payload
+        if target_scan_p_of_success:
+            self.target_scan_p_of_success = target_scan_p_of_success
+        if c2_beacon_p_of_success:
+            self.c2_beacon_p_of_success = c2_beacon_p_of_success
+        if ransomware_encrypt_p_of_success:
+            self.ransomware_encrypt_p_of_success = ransomware_encrypt_p_of_success
+        if repeat:
+            self.repeat = repeat
+        self.sys_log.info(
+            f"{self.name}: Configured the {self.name} with {server_ip_address=}, {payload=}, {server_password=}, "
+            f"{repeat=}."
+        )
+
+    def _install(self):
+        """
+        Simulate the install stage in the kill-chain.
+
+        Advances the attack stage to 'ACTIVATE' if successful.
+
+        From this attack stage onwards.
+        the ransomware application is now visible from this point onwardin the observation space.
+        """
+        if self.attack_stage == RansomwareAttackStage.DOWNLOAD:
+            self.sys_log.info(f"{self.name}: Malware installed on the local file system")
+            downloads_folder = self.file_system.get_folder(folder_name="downloads")
+            ransomware_file = downloads_folder.get_file(file_name="ransom_script.pdf")
+            ransomware_file.num_access += 1
+            self.attack_stage = RansomwareAttackStage.INSTALL
+
+    def _setup_beacon(self):
+        """
+        Simulates setting up a c2 beacon; currently a pseudo step for increasing red variance.
+
+        Advances the attack stage to 'COMMAND AND CONTROL` if successful.
+
+        :param p_of_sucess: Probability of a successful c2 setup (Advancing this step),
+                            by default the success rate is 0.5
+        """
+        if self.attack_stage == RansomwareAttackStage.PROPAGATE:
+            self.sys_log.info(f"{self.name} Attempting to set up C&C Beacon - Scan 1/2")
+            if simulate_trial(self.c2_beacon_p_of_success):
+                self.sys_log.info(f"{self.name} C&C Successful setup - Scan 2/2")
+                c2c_setup = True  # TODO Implement the c2c step via an FTP Application/Service
+                if c2c_setup:
+                    self.attack_stage = RansomwareAttackStage.COMMAND_AND_CONTROL
+
+    def _perform_target_scan(self):
+        """
+        Perform a simulated port scan to check for open SQL ports.
+
+        Advances the attack stage to `PROPAGATE` if successful.
+
+        :param p_of_success: Probability of successful port scan, by default 0.1.
+        """
+        if self.attack_stage == RansomwareAttackStage.ACTIVATE:
+            # perform a port scan to identify that the SQL port is open on the server
+            self.sys_log.info(f"{self.name}: Scanning for vulnerable databases - Scan 0/2")
+            if simulate_trial(self.target_scan_p_of_success):
+                self.sys_log.info(f"{self.name}: Found a target database! Scan 1/2")
+                port_is_open = True  # TODO Implement a NNME Triggering scan as a seperate Red Application
+                if port_is_open:
+                    self.attack_stage = RansomwareAttackStage.PROPAGATE
+
+    def attack(self) -> bool:
+        """Perform the attack steps after opening the application."""
+        if not self._can_perform_action():
+            _LOGGER.debug("Ransomware application is unable to perform it's actions.")
+            self.run()
+        self.num_executions += 1
+        return self._application_loop()
+
+    def _perform_ransomware_encrypt(self):
+        """
+        Execute the Ransomware Encrypt payload on the target.
+
+        Advances the attack stage to `COMPLETE` if successful, or 'FAILED' if unsuccessful.
+        :param p_of_success: Probability of successfully performing ransomware encryption, by default 0.1.
+        """
+        if self._host_db_client is None:
+            self.sys_log.info(f"{self.name}: Failed to connect to db_client - Ransomware Script")
+            self.attack_stage = RansomwareAttackStage.FAILED
+            return
+
+        self._host_db_client.server_ip_address = self.server_ip_address
+        self._host_db_client.server_password = self.server_password
+        if self.attack_stage == RansomwareAttackStage.COMMAND_AND_CONTROL:
+            if simulate_trial(self.ransomware_encrypt_p_of_success):
+                self.sys_log.info(f"{self.name}: Attempting to launch payload")
+                if not len(self._host_db_client.connections):
+                    self._host_db_client.connect()
+                if len(self._host_db_client.connections):
+                    self._host_db_client.query(self.payload)
+                    self.sys_log.info(f"{self.name} Payload delivered: {self.payload}")
+                    attack_successful = True
+                    if attack_successful:
+                        self.sys_log.info(f"{self.name}: Payload Successful")
+                        self.attack_stage = RansomwareAttackStage.SUCCEEDED
+                    else:
+                        self.sys_log.info(f"{self.name}: Payload failed")
+                        self.attack_stage = RansomwareAttackStage.FAILED
+        else:
+            self.sys_log.error("Attack Attempted to launch too quickly")
+            self.attack_stage = RansomwareAttackStage.FAILED
+
+    def _local_download(self):
+        """Downloads itself via the onto the local file_system."""
+        if self.attack_stage == RansomwareAttackStage.NOT_STARTED:
+            if self._local_download_verify():
+                self.attack_stage = RansomwareAttackStage.DOWNLOAD
+            else:
+                self.sys_log.info("Malware failed to create a installation location")
+                self.attack_stage = RansomwareAttackStage.FAILED
+        else:
+            self.sys_log.info("Malware failed to download")
+            self.attack_stage = RansomwareAttackStage.FAILED
+
+    def _local_download_verify(self) -> bool:
+        """Verifies a download location - Creates one if needed."""
+        for folder in self.file_system.folders:
+            if self.file_system.folders[folder].name == "downloads":
+                self.file_system.num_file_creations += 1
+                return True
+
+        self.file_system.create_folder("downloads")
+        self.file_system.create_file(folder_name="downloads", file_name="ransom_script.pdf")
+        return True

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

@@ -88,6 +88,10 @@ class SysLog:
         root.mkdir(exist_ok=True, parents=True)
         return root / f"{self.hostname}_sys.log"
 
+    def _write_to_terminal(self, msg: str, level: str, to_terminal: bool = False):
+        if to_terminal or SIM_OUTPUT.write_sys_log_to_terminal:
+            print(f"{self.hostname}: ({level}) {msg}")
+
     def debug(self, msg: str, to_terminal: bool = False):
         """
         Logs a message with the DEBUG level.
@@ -97,8 +101,7 @@ class SysLog:
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.debug(msg)
-        if to_terminal:
-            print(msg)
+        self._write_to_terminal(msg, "DEBUG", to_terminal)
 
     def info(self, msg: str, to_terminal: bool = False):
         """
@@ -109,8 +112,7 @@ class SysLog:
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.info(msg)
-        if to_terminal:
-            print(msg)
+        self._write_to_terminal(msg, "INFO", to_terminal)
 
     def warning(self, msg: str, to_terminal: bool = False):
         """
@@ -121,8 +123,7 @@ class SysLog:
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.warning(msg)
-        if to_terminal:
-            print(msg)
+        self._write_to_terminal(msg, "WARNING", to_terminal)
 
     def error(self, msg: str, to_terminal: bool = False):
         """
@@ -133,8 +134,7 @@ class SysLog:
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.error(msg)
-        if to_terminal:
-            print(msg)
+        self._write_to_terminal(msg, "ERROR", to_terminal)
 
     def critical(self, msg: str, to_terminal: bool = False):
         """
@@ -145,5 +145,4 @@ class SysLog:
         """
         if SIM_OUTPUT.save_sys_logs:
             self.logger.critical(msg)
-        if to_terminal:
-            print(msg)
+        self._write_to_terminal(msg, "CRITICAL", to_terminal)

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

@@ -141,8 +141,7 @@ class DatabaseService(Service):
         """Returns the database file."""
         return self.file_system.get_file(folder_name="database", file_name="database.db")
 
-    @property
-    def folder(self) -> Folder:
+    def _return_database_folder(self) -> Folder:
         """Returns the database folder."""
         return self.file_system.get_folder_by_id(self.db_file.folder_id)
 
@@ -187,7 +186,10 @@ class DatabaseService(Service):
         }
 
     def _process_sql(
-        self, query: Literal["SELECT", "DELETE", "INSERT"], query_id: str, connection_id: Optional[str] = None
+        self,
+        query: Literal["SELECT", "DELETE", "INSERT", "ENCRYPT"],
+        query_id: str,
+        connection_id: Optional[str] = None,
     ) -> Dict[str, Union[int, List[Any]]]:
         """
         Executes the given SQL query and returns the result.
@@ -196,6 +198,7 @@ class DatabaseService(Service):
         - SELECT : returns the data
         - DELETE : deletes the data
         - INSERT : inserts the data
+        - ENCRYPT : corrupts the data
 
         :param query: The SQL query to be executed.
         :return: Dictionary containing status code and data fetched.
@@ -207,7 +210,15 @@ class DatabaseService(Service):
             return {"status_code": 404, "type": "sql", "data": False}
 
         if query == "SELECT":
-            if self.db_file.health_status == FileSystemItemHealthStatus.GOOD:
+            if self.db_file.health_status == FileSystemItemHealthStatus.CORRUPT:
+                return {
+                    "status_code": 200,
+                    "type": "sql",
+                    "data": False,
+                    "uuid": query_id,
+                    "connection_id": connection_id,
+                }
+            elif self.db_file.health_status == FileSystemItemHealthStatus.GOOD:
                 return {
                     "status_code": 200,
                     "type": "sql",
@@ -226,6 +237,20 @@ class DatabaseService(Service):
                 "uuid": query_id,
                 "connection_id": connection_id,
             }
+        elif query == "ENCRYPT":
+            self.file_system.num_file_creations += 1
+            self.db_file.health_status = FileSystemItemHealthStatus.CORRUPT
+            self.db_file.num_access += 1
+            database_folder = self._return_database_folder()
+            database_folder.health_status = FileSystemItemHealthStatus.CORRUPT
+            self.file_system.num_file_deletions += 1
+            return {
+                "status_code": 200,
+                "type": "sql",
+                "data": False,
+                "uuid": query_id,
+                "connection_id": connection_id,
+            }
         elif query == "INSERT":
             if self.health_state_actual == SoftwareHealthState.GOOD:
                 return {

src/primaite/simulator/system/services/ntp/ntp_client.py

@@ -87,13 +87,9 @@ class NTPClient(Service):
         :return: True if successful, False otherwise.
         """
         if not isinstance(payload, NTPPacket):
-            _LOGGER.debug(f"{payload} is not a NTPPacket")
+            _LOGGER.debug(f"{self.name}: Failed to parse NTP update")
             return False
         if payload.ntp_reply.ntp_datetime:
-            self.sys_log.info(
-                f"{self.name}: \
-                              Received time update from NTP server{payload.ntp_reply.ntp_datetime}"
-            )
             self.time = payload.ntp_reply.ntp_datetime
             return True
 
@@ -124,5 +120,3 @@ class NTPClient(Service):
         if self.operating_state == ServiceOperatingState.RUNNING:
             # request time from server
             self.request_time()
-        else:
-            self.sys_log.debug(f"{self.name} ntp client not running")

src/primaite/simulator/system/software.py

@@ -224,6 +224,10 @@ class Software(SimComponent):
         if self.health_state_actual == SoftwareHealthState.FIXING:
             self._update_fix_status()
 
+    def pre_timestep(self, timestep: int) -> None:
+        """Apply pre-timestep logic."""
+        super().pre_timestep(timestep)
+
 
 class IOSoftware(Software):
     """