3086 UC7 Migration - All YAMLS, tests and notebooks. A few lingering issues such as the OS-SCAN not working and agent logs not appearing.

2025-02-10 14:39:28 +00:00
parent 0d1edf0362
commit d8c8aa40a4
118 changed files with 21789 additions and 368 deletions
--- a/tests/e2e_integration_tests/threat_actor_profiles/init.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/init.py
@@ -0,0 +1 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_abstract_tap.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_abstract_tap.py
@@ -0,0 +1,143 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+
+
+def uc7_tap001_env() -> PrimaiteGymEnv:
+    with open(_EXAMPLE_CFG / "uc7_config.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+
+    for a in cfg["agents"]:
+        if a["ref"] == "attacker":
+            tap_cfg = a
+
+    tap_cfg["agent_settings"]["start_step"] = 1
+    tap_cfg["agent_settings"]["frequency"] = 5
+    tap_cfg["agent_settings"]["variance"] = 0
+
+    env = PrimaiteGymEnv(env_config=cfg)
+
+    return env
+
+
+def uc7_tap003_env(**kwargs) -> PrimaiteGymEnv:
+    """Setups the UC7 TAP003 Game with the following settings:
+
+    start_step = Start on Step 1
+    frequency = Attack Every 5 Steps
+
+    Each PyTest will define the rest of the TAP & Kill Chain settings via **Kwargs
+    """
+    with open(_EXAMPLE_CFG / "uc7_config_tap003.yaml", "r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+
+    for a in cfg["agents"]:
+        if a["ref"] == "attacker":
+            tap_cfg = a
+
+    tap_cfg["agent_settings"]["start_step"] = 1
+    tap_cfg["agent_settings"]["frequency"] = 5
+    tap_cfg["agent_settings"]["variance"] = 0
+
+    if "repeat_kill_chain" in kwargs:
+        tap_cfg["agent_settings"]["repeat_kill_chain"] = kwargs["repeat_kill_chain"]
+    if "repeat_kill_chain_stages" in kwargs:
+        tap_cfg["agent_settings"]["repeat_kill_chain_stages"] = kwargs["repeat_kill_chain_stages"]
+    if "planning_probability" in kwargs:
+        tap_cfg["agent_settings"]["kill_chain"]["PLANNING"]["probability"] = kwargs["planning_probability"]
+    if "custom_kill_chain" in kwargs:
+        tap_cfg["agent_settings"]["kill_chain"] = kwargs["custom_kill_chain"]
+    if "starting_nodes" in kwargs:
+        tap_cfg["agent_settings"]["starting_nodes"] = kwargs["starting_nodes"]
+    if "target_nodes" in kwargs:
+        tap_cfg["agent_settings"]["target_nodes"] = kwargs["target_nodes"]
+
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap001_setup():
+    """Tests abstract TAP's following methods:
+    1. _setup_kill_chain
+    2. _setup_agent_kill_chain
+    3. _setup_tap_applications
+    """
+    env = uc7_tap001_env()  # Using TAP001 for PyTests.
+    tap: TAP001 = env.game.agents["attacker"]
+
+    # check the kill chain loaded correctly
+    assert tap.selected_kill_chain is MobileMalwareKillChain
+    assert tap.selected_kill_chain.FAILED == BaseKillChain.FAILED
+    assert tap.selected_kill_chain.SUCCEEDED == BaseKillChain.SUCCEEDED
+    assert tap.selected_kill_chain.NOT_STARTED == BaseKillChain.NOT_STARTED
+
+    if sn := tap.config.agent_settings.default_starting_node:
+        assert tap.starting_node == sn
+    else:
+        assert tap.starting_node in tap.config.agent_settings.starting_nodes
+
+    if ti := tap.config.agent_settings.default_target_ip:
+        assert tap.target_ip == ti
+    else:
+        assert tap.target_ip in tap.config.agent_settings.target_ips
+
+    assert tap.next_execution_timestep == tap.config.agent_settings.start_step
+
+    assert tap.current_host == tap.starting_node
+
+
+def test_abstract_tap_select_start_node():
+    """Tests that Abstract TAP's _select_start_node"""
+    env = uc7_tap003_env(repeat_kill_chain=True, repeat_kill_chain_stages=True)  # Using TAP003 for PyTests.
+    tap: TAP003 = env.game.agents["attacker"]
+
+    assert tap.starting_node == "ST-PROJ-A-PRV-PC-1"
+    assert tap.current_host == tap.starting_node
+
+
+def test_outcome_handler():
+    """Tests Abstract Tap's outcome handler concludes the episode when the kill chain fails."""
+    env = uc7_tap003_env(repeat_kill_chain=False, repeat_kill_chain_stages=False)  # Using TAP003 for PyTests.
+    tap: TAP003 = env.game.agents["attacker"]
+    tap.current_kill_chain_stage = BaseKillChain.FAILED
+
+    for _ in range(6):
+        env.step(0)
+    assert tap.actions_concluded == True
+
+
+def test_abstract_tap_kill_chain_repeat():
+    """Tests that the kill chain repeats from the beginning upon failure."""
+    env = uc7_tap003_env(repeat_kill_chain=True, repeat_kill_chain_stages=False)  # Using TAP003 for PyTests.
+    tap: TAP003 = env.game.agents["attacker"]
+    for _ in range(15):
+        env.step(0)  # Steps directly to the Access Stage
+    assert tap.current_kill_chain_stage == InsiderKillChain.ACCESS
+    tap.current_kill_chain_stage = BaseKillChain.FAILED
+    for _ in range(5):
+        env.step(0)  # Steps to manipulation - but failure causes the kill chain to restart.
+    assert tap.actions_concluded == False
+    assert tap.current_kill_chain_stage == InsiderKillChain.RECONNAISSANCE
+
+    """Tests that kill chain stages repeat when expected"""
+    env = uc7_tap003_env(
+        repeat_kill_chain=True, repeat_kill_chain_stages=True, planning_probability=0
+    )  # Using TAP003 for PyTests.
+    tap: TAP003 = env.game.agents["attacker"]
+    tap.current_kill_chain_stage = InsiderKillChain.PLANNING
+    for _ in range(15):
+        env.step(0)  #  Attempts to progress past the PLANNING stage multiple times.
+    assert tap.actions_concluded == False
+    assert tap.current_kill_chain_stage == InsiderKillChain.PLANNING
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_kill_chain_methods.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_kill_chain_methods.py
@@ -0,0 +1,69 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+
+
+def uc7_tap003_env() -> PrimaiteGymEnv:
+    """Setups the UC7 TAP003 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config_tap003.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def uc7_tap001_env() -> PrimaiteGymEnv:
+    """Setup the UC7 TAP001 Game with the start_step & frequency set to 1 & 2 respectively. Probabilities are set to 1"""
+    with open(_EXAMPLE_CFG / "uc7_config.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap003_insider_kill_chain_load():
+    """Tests that tap003's insider kill chain is successfully loaded into the tap.selected_kill_chain attribute."""
+    env = uc7_tap003_env()  # Using TAP003 for PyTests.
+    tap: TAP003 = env.game.agents["attacker"]
+    # Asserting that the Base Kill Chain intEnum stages are loaded
+    assert BaseKillChain.FAILED in [enums for enums in tap.selected_kill_chain]
+    assert BaseKillChain.SUCCEEDED in [enums for enums in tap.selected_kill_chain]
+    assert BaseKillChain.NOT_STARTED in [enums for enums in tap.selected_kill_chain]
+    # Asserting that the Insider Kill Chain intenum stages are loaded.
+    assert len(InsiderKillChain.__members__) == len(tap.selected_kill_chain.__members__)
+
+
+def test_tap001_mobile_malware_kill_chain_load():
+    """Tests that tap001's mobile malware is successfully loaded into the tap.selected_kill_chain attribute."""
+    env = uc7_tap001_env()  # Using TAP003 for PyTests.
+    tap: TAP001 = env.game.agents["attacker"]
+    # Asserting that the Base Kill Chain intEnum stages are loaded.
+    assert BaseKillChain.FAILED in [enums for enums in tap.selected_kill_chain]
+    assert BaseKillChain.SUCCEEDED in [enums for enums in tap.selected_kill_chain]
+    assert BaseKillChain.NOT_STARTED in [enums for enums in tap.selected_kill_chain]
+    # Asserting that the Insider Kill Chain intEnum stages are loaded.
+    assert len(MobileMalwareKillChain.__members__) == len(tap.selected_kill_chain.__members__)
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_kill_chain_repeat.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_kill_chain_repeat.py
@@ -0,0 +1,109 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+
+
+def uc7_tap001_env(**kwargs) -> PrimaiteGymEnv:
+    """Setups the UC7 tap001 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain"] = kwargs["repeat_kill_chain"]
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain_stages"] = kwargs["repeat_kill_chain_stages"]
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PROPAGATE"]["probability"] = kwargs["propagate_probability"]
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PAYLOAD"]["probability"] = kwargs["payload_probability"]
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap001_repeating_kill_chain():
+    """Tests to check that tap001 repeats it's kill chain after success"""
+    env = uc7_tap001_env(
+        repeat_kill_chain=True,
+        repeat_kill_chain_stages=True,
+        payload_probability=1,
+        propagate_probability=1,
+    )
+    tap001: TAP001 = env.game.agents["attacker"]
+    # Looping for 50 timesteps - As the agent is set to execute an action every 2 timesteps
+    # This is the equivalent of the agent taking 20 actions.
+    for _ in range(50):  # This for loop should never actually fully complete.
+        if tap001.current_kill_chain_stage == BaseKillChain.SUCCEEDED:
+            break
+        env.step(0)
+
+    # Catches if the above for loop fully completes.
+    # This test uses a probability of 1 for all stages and a variance of 2 timesteps
+    # Thus the for loop above should never fail.
+    # If this occurs then there is an error somewhere in either:
+    # 1. The TAP Logic
+    # 2. Failing Agent Actions are causing the TAP to fail. (See tap_return_handler).
+    if tap001.current_kill_chain_stage != BaseKillChain.SUCCEEDED:
+        pytest.fail("Attacker Never Reached SUCCEEDED - Please evaluate current TAP Logic.")
+
+    # Stepping twice for the succeeded logic to kick in:
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.DOWNLOAD.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.INSTALL.name
+
+
+def test_tap001_repeating_kill_chain_stages():
+    """Tests to check that tap001 repeats it's kill chain after failing a kill chain stage."""
+    env = uc7_tap001_env(
+        repeat_kill_chain=True,
+        repeat_kill_chain_stages=True,
+        payload_probability=1,
+        propagate_probability=0,
+        # Probability 0 = Will never be able to perform the access stage and progress to Manipulation.
+    )
+    tap001: TAP001 = env.game.agents["attacker"]
+    env.step(0)  # Skipping not started
+    env.step(0)  # Successful on the first stage
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.DOWNLOAD.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.INSTALL.name
+    env.step(0)  # Successful progression to the second stage
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.INSTALL.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.ACTIVATE.name
+    env.step(0)  # Successful progression to the third stage
+    env.step(0)
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.ACTIVATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    env.step(0)  # Successful progression to the Fourth stage
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+    env.step(0)  # FAILURE -- Unsuccessful progression to the Fourth stage
+    env.step(0)
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+    assert tap001.current_stage_progress == KillChainStageProgress.PENDING
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_kill_chain_stages.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_kill_chain_stages.py
@@ -0,0 +1,215 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+from primaite.simulator.file_system.file_system_item_abc import FileSystemItemHealthStatus
+from primaite.simulator.system.applications.red_applications.c2.c2_beacon import C2Beacon
+from primaite.simulator.system.services.database.database_service import DatabaseService
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+REPEAT_KILL_CHAIN = False  # Should the TAP repeat the kill chain after success/failure?
+REPEAT_KILL_CHAIN_STAGES = False  # Should the TAP restart from it's previous stage on failure?
+KILL_CHAIN_PROBABILITY = 1  # Blank probability for agent 'success'
+DATA_EXFIL = True  # Data exfiltration on the payload stage is enabled.
+
+
+def uc7_tap001_env() -> PrimaiteGymEnv:
+    """Setups the UC7 tap001 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain"] = REPEAT_KILL_CHAIN_STAGES
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain_stages"] = REPEAT_KILL_CHAIN_STAGES
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PAYLOAD"]["probability"] = KILL_CHAIN_PROBABILITY
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PROPAGATE"]["probability"] = KILL_CHAIN_PROBABILITY
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PAYLOAD"]["exfiltrate"] = DATA_EXFIL
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap001_kill_chain_stage_DOWNLOAD():
+    """Tests that the DOWNLOAD Mobile Malware step works as expected and the expected impacts are made in the simulation."""
+
+    # Instantiating the relevant simulation/game objects:
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+    starting_host = env.game.simulation.network.get_node_by_hostname(tap001.starting_node)
+    assert tap001.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    # Frequency is set to two steps
+    env.step(0)
+    env.step(0)
+
+    env.step(0)
+    env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.DOWNLOAD.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.INSTALL.name
+    assert tap001.current_stage_progress == KillChainStageProgress.IN_PROGRESS
+
+    # Creating the "downloads" folder
+    env.step(0)
+    env.step(0)
+
+    assert starting_host.software_manager.file_system.get_folder(folder_name="downloads")
+    assert starting_host.software_manager.file_system.get_file(folder_name="downloads", file_name="malware_dropper.ps1")
+
+    # Testing that the num_file_increase works
+
+    assert starting_host.file_system.num_file_creations == 1
+
+
+def test_tap001_kill_chain_stage_INSTALL():
+    """Tests that the INSTALL Mobile Malware step works as expected and the expected impacts are made in the simulation."""
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+    # The tap001's Starting Client:
+    starting_host = env.game.simulation.network.get_node_by_hostname(tap001.starting_node)
+
+    # Skipping directly to the activate stage
+    for _ in range(6):
+        env.step(0)
+
+    # Testing that tap001 Enters into the expected kill chain stages
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.INSTALL.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.ACTIVATE.name
+
+    env.step(0)  # Allows the agent action to resolve.
+    env.step(0)
+
+    ransomware_dropper_file = starting_host.software_manager.file_system.get_file(
+        folder_name="downloads", file_name="malware_dropper.ps1"
+    )
+    assert ransomware_dropper_file.num_access == 1
+
+
+def test_tap001_kill_chain_stage_ACTIVATE():
+    """Tests that the ACTIVATE Mobile Malware step works as expected and the current impacts are made in the simulation."""
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+    # The tap001's Starting Client:
+    starting_host = env.game.simulation.network.get_node_by_hostname(tap001.starting_node)
+
+    # Skipping directly to the activate stage
+    for _ in range(8):
+        env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.ACTIVATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+
+    # Installing ransomware-script Application
+    env.step(0)
+    env.step(0)
+
+    # Installing NMAP Application
+    env.step(0)
+    env.step(0)
+
+    # These asserts will fail if the applications are not present in the software_manager
+    assert starting_host.software_manager.software["ransomware-script"]
+    assert starting_host.software_manager.software["nmap"]
+
+
+def test_tap001_kill_chain_stage_PROPAGATE():
+    """Tests that the ACTIVATE Mobile Malware step works as expected and the current impacts are made in the simulation."""
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+
+    for _ in range(12):
+        env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+
+    # Specific Stage by Stage Propagate Testing is done in test_tap001_propagate.
+    fail_safe_var = 0
+    while tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE:
+        env.step(0)
+        assert tap001.current_stage_progress == KillChainStageProgress.IN_PROGRESS
+        fail_safe_var += 1
+        if fail_safe_var == 100:
+            pytest.fail("Fail Safe Variable was hit! -- Propagate step is running indefinitely")
+
+
+def test_tap001_kill_chain_stage_COMMAND_AND_CONTROL():
+    """Tests that the Command And Control Mobile Malware step works as expected and the current impacts are made in the simulation."""
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+    fail_safe_var = 0
+
+    for _ in range(28):
+        env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.PAYLOAD.name
+
+    while tap001.current_kill_chain_stage == MobileMalwareKillChain.COMMAND_AND_CONTROL:
+        env.step(0)
+        fail_safe_var += 1
+        env.game.simulation.network.airspace.show()
+        if fail_safe_var == 100:
+            pytest.fail(reason="Fail Safe Variable was hit! -- Propagate step is running indefinitely")
+
+    starting_host = env.game.simulation.network.get_node_by_hostname(tap001.starting_node)
+
+    c2_beacon: C2Beacon = starting_host.software_manager.software["c2-beacon"]
+
+    assert c2_beacon.c2_connection_active is True
+
+
+def test_tap001_kill_chain_stage_PAYLOAD():
+    """Tests that the PAYLOAD Mobile Malware step works as expected and the current impacts are made in the simulation."""
+
+    env = uc7_tap001_env()
+    tap001: TAP001 = env.game.agents["attacker"]
+
+    # The tap001's Target Database
+    target_host = env.game.simulation.network.get_node_by_hostname("ST-DATA-PRV-SRV-DB")
+    db_server_service: DatabaseService = target_host.software_manager.software.get("database-service")
+
+    # Green agent status requests are tested within the ransomware application tests.
+    # See test_ransomware_disrupts_green_agent_connection for further reference.
+    assert db_server_service.db_file.health_status is FileSystemItemHealthStatus.GOOD
+
+    fail_safe_var = 0
+    while tap001.current_kill_chain_stage != MobileMalwareKillChain.PAYLOAD:
+        env.step(0)
+        fail_safe_var += 1
+        if fail_safe_var == 100:
+            pytest.fail(reason="Fail Safe Variable was hit! -- a step is running indefinitely")
+
+    for _ in range(12):
+        env.step(0)
+
+    assert db_server_service.db_file.health_status is FileSystemItemHealthStatus.CORRUPT
+
+    # Asserting we've managed to the database.db file onto the starting node & server
+    starting_host = env.game.simulation.network.get_node_by_hostname(tap001.starting_node)
+    c2_host = env.game.simulation.network.get_node_by_hostname(tap001.c2_settings["c2_server"])
+
+    assert starting_host.file_system.access_file(folder_name="exfiltration_folder", file_name="database.db")
+    assert c2_host.file_system.access_file(folder_name="exfiltration_folder", file_name="database.db")
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_propagate_stage.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap001_propagate_stage.py
@@ -0,0 +1,140 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+from primaite.simulator.file_system.file_system_item_abc import FileSystemItemHealthStatus
+from primaite.simulator.system.applications.red_applications.c2.c2_beacon import C2Beacon
+from primaite.simulator.system.services.database.database_service import DatabaseService
+
+# Defining generic tap constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+REPEAT_KILL_CHAIN = False  # Should the TAP repeat the kill chain after success/failure?
+REPEAT_KILL_CHAIN_STAGES = False  # Should the TAP restart from it's previous stage on failure?
+KILL_CHAIN_PROBABILITY = 1  # Blank probability for agent 'success'
+
+
+def uc7_tap001_env(**kwargs) -> PrimaiteGymEnv:
+    """Setups the UC7 tap001 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        agent_cfg = cfg["agents"][32]["agent_settings"]
+        agent_cfg["start_step"] = START_STEP
+        agent_cfg["frequency"] = FREQUENCY
+        agent_cfg["variance"] = VARIANCE
+        agent_cfg["repeat_kill_chain"] = REPEAT_KILL_CHAIN_STAGES
+        agent_cfg["repeat_kill_chain_stages"] = REPEAT_KILL_CHAIN_STAGES
+        agent_cfg["kill_chain"]["PAYLOAD"]["probability"] = KILL_CHAIN_PROBABILITY
+        agent_cfg["kill_chain"]["PROPAGATE"]["probability"] = KILL_CHAIN_PROBABILITY
+        agent_cfg["kill_chain"]["PROPAGATE"]["scan_attempts"] = kwargs["scan_attempts"]
+        agent_cfg["kill_chain"]["PAYLOAD"]["payload"] = kwargs["payload"]
+        agent_cfg["kill_chain"]["PROPAGATE"]["network_addresses"] = kwargs["network_addresses"]
+        if "repeat_scan" in kwargs:
+            agent_cfg["kill_chain"]["PROPAGATE"]["repeat_scan"] = kwargs["repeat_scan"]
+        if "starting_nodes" in kwargs:
+            agent_cfg["starting_nodes"] = kwargs["starting_nodes"]
+            agent_cfg["default_starting_node"] = kwargs["starting_nodes"][0]
+        if "target_ips" in kwargs:
+            agent_cfg["target_ips"] = kwargs["target_ips"]
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap001_kill_chain_stage_PROPAGATE_default():
+    """Tests that the PROPAGATE Mobile Malware step works as expected and the current impacts are made in the simulation."""
+    payload = "ENCRYPT"
+    scan_attempts = 10
+    network_addresses = [
+        "192.168.230.0/29",
+        "192.168.10.0/26",
+        "192.168.20.0/30",
+        "192.168.240.0/29",
+        "192.168.220.0/29",
+    ]
+    env = uc7_tap001_env(payload=payload, scan_attempts=scan_attempts, network_addresses=network_addresses)
+    tap001: TAP001 = env.game.agents["attacker"]
+
+    # First Kill Chain Stages
+    for _ in range(12):
+        env.step(0)
+
+    # Assert that we're about to enter into the propagate stage.
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+
+    # Move into the propagate stage.
+    while tap001.current_kill_chain_stage == MobileMalwareKillChain.PROPAGATE:
+        env.step(0)
+
+    # Assert that we've successfully moved into the command and control stage.
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.PAYLOAD.name
+
+
+def test_tap001_kill_chain_stage_PROPAGATE_different_starting_node():
+    """Tests that the PROPAGATE Mobile Malware step works as expected and the current impacts are made in the simulation from a different starting node."""
+    payload = "ENCRYPT"
+    scan_attempts = 10
+    network_addresses = [
+        "192.168.230.0/29",
+        "192.168.10.0/26",
+        "192.168.20.0/30",
+        "192.168.240.0/29",
+        "192.168.220.0/29",
+    ]
+    starting_nodes = ["ST-PROJ-B-PRV-PC-2", "ST-PROJ-C-PRV-PC-3"]
+
+    env = uc7_tap001_env(
+        payload=payload, scan_attempts=scan_attempts, network_addresses=network_addresses, starting_nodes=starting_nodes
+    )
+
+    tap001: TAP001 = env.game.agents["attacker"]
+
+    for _ in range(12):
+        env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.PROPAGATE.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+
+    # Specific Stage by Stage Propagate Testing is done in test_tap001_propagate.
+    while tap001.current_kill_chain_stage == MobileMalwareKillChain.PROPAGATE:
+        env.step(0)
+
+    assert tap001.current_kill_chain_stage.name == MobileMalwareKillChain.COMMAND_AND_CONTROL.name
+    assert tap001.next_kill_chain_stage.name == MobileMalwareKillChain.PAYLOAD.name
+
+
+def test_tap001_kill_chain_stage_PROPAGATE_repeat_scan():
+    """Tests that the PROPAGATE Mobile Malware step will fail when the target is unable to be located."""
+    payload = "ENCRYPT"
+    scan_attempts = 20
+    repeat_scan = True
+    network_addresses = ["192.168.1.0/24", "192.168.0.0/28", "100.64.0.0/30", "172.168.0.0/28"]
+    env = uc7_tap001_env(
+        payload=payload, scan_attempts=scan_attempts, network_addresses=network_addresses, repeat_scan=repeat_scan
+    )
+    for _ in range(12):
+        env.step(0)
+
+    tap001: TAP001 = env.game.agents["attacker"]
+
+    while tap001.current_kill_chain_stage == MobileMalwareKillChain.PROPAGATE:
+        env.step(0)
+
+    # As the given network_address does not contain the target, we should failed because the maximum amount of scan attempts has been reached
+    assert tap001.scans_complete == 20
+    assert tap001.current_kill_chain_stage == MobileMalwareKillChain.FAILED
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_kill_chain_repeat.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_kill_chain_repeat.py
@@ -0,0 +1,101 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+
+
+def uc7_tap003_env(**kwargs) -> PrimaiteGymEnv:
+    """Setups the UC7 TAP003 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config_tap003.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain"] = kwargs["repeat_kill_chain"]
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain_stages"] = kwargs["repeat_kill_chain_stages"]
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["MANIPULATION"]["probability"] = kwargs[
+            "manipulation_probability"
+        ]
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["ACCESS"]["probability"] = kwargs["access_probability"]
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PLANNING"]["probability"] = kwargs["planning_probability"]
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap003_repeating_kill_chain():
+    """Tests to check that TAP003 repeats it's kill chain after success"""
+    env = uc7_tap003_env(
+        repeat_kill_chain=True,
+        repeat_kill_chain_stages=True,
+        manipulation_probability=1,
+        access_probability=1,
+        planning_probability=1,
+    )
+    tap003: TAP003 = env.game.agents["attacker"]
+    for _ in range(40):  # This for loop should never actually fully complete.
+        if tap003.current_kill_chain_stage == BaseKillChain.SUCCEEDED:
+            break
+        env.step(0)
+
+    # Catches if the above for loop fully completes.
+    # This test uses a probability of 1 for all stages and a variance of 2 timesteps
+    # Thus the for loop above should never fail.
+    # If this occurs then there is an error somewhere in either:
+    # 1. The TAP Logic
+    # 2. Failing Agent Actions are causing the TAP to fail. (See tap_return_handler).
+    if tap003.current_kill_chain_stage != BaseKillChain.SUCCEEDED:
+        pytest.fail("Attacker Never Reached SUCCEEDED - Please evaluate current TAP Logic.")
+
+    # Stepping twice for the succeeded logic to kick in:
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+
+
+def test_tap003_repeating_kill_chain_stages():
+    """Tests to check that TAP003 repeats it's kill chain after failing a kill chain stage."""
+    env = uc7_tap003_env(
+        repeat_kill_chain=True,
+        repeat_kill_chain_stages=True,
+        manipulation_probability=1,
+        # Probability 0 = Will never be able to perform the access stage and progress to Manipulation.
+        access_probability=0,
+        planning_probability=1,
+    )
+    tap003: TAP003 = env.game.agents["attacker"]
+    env.step(0)  # Skipping not started
+    env.step(0)  # Successful on the first stage
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    env.step(0)  # Successful progression to the second stage
+    env.step(0)
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    env.step(0)  # Successfully moved onto access.
+    env.step(0)
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
+    env.step(0)  # Failure to progress past the third stage.
+    env.step(0)
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_kill_chain_stages.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_kill_chain_stages.py
@@ -0,0 +1,232 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+from primaite.simulator.network.hardware.nodes.network.router import ACLAction
+
+# Defining constants.
+
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+REPEAT_KILL_CHAIN = False  # Should the TAP repeat the kill chain after success/failure?
+REPEAT_KILL_CHAIN_STAGES = False  # Should the TAP restart from it's previous stage on failure?
+KILL_CHAIN_PROBABILITY = 1  # Blank probability for agent 'success'
+
+
+def uc7_tap003_env() -> PrimaiteGymEnv:
+    """Setups the UC7 TAP003 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config_tap003.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][32]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][32]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][32]["agent_settings"]["variance"] = VARIANCE
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain"] = REPEAT_KILL_CHAIN_STAGES
+        cfg["agents"][32]["agent_settings"]["repeat_kill_chain_stages"] = REPEAT_KILL_CHAIN_STAGES
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["MANIPULATION"]["probability"] = KILL_CHAIN_PROBABILITY
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["ACCESS"]["probability"] = KILL_CHAIN_PROBABILITY
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["PLANNING"]["probability"] = KILL_CHAIN_PROBABILITY
+        cfg["agents"][32]["agent_settings"]["kill_chain"]["EXPLOIT"]["probability"] = KILL_CHAIN_PROBABILITY
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def environment_step(i: int, env: PrimaiteGymEnv) -> PrimaiteGymEnv:
+    """Carries out i (given parameter) steps in the environment.."""
+    for x in range(i):
+        env.step(0)
+    return env
+
+
+def test_tap003_kill_chain_stage_reconnaissance():
+    """Tests the successful/failed handlers in the reconnaissance stage in the Insider Kill Chain InsiderKillChain"""
+
+    # Instantiating the relevant simulation/game objects:
+    env = uc7_tap003_env()
+    tap003: TAP003 = env.game.agents["attacker"]
+    assert tap003.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    # Frequency is set to two steps
+    env = environment_step(i=2, env=env)
+
+    # Testing that TAP003 Enters into the expected kill chain stages
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+
+
+def test_tap003_kill_chain_stage_planning():
+    """Tests the successful/failed handlers in the planning stage in the Insider Kill Chain (TAP003)"""
+    env = uc7_tap003_env()
+    tap003: TAP003 = env.game.agents["attacker"]
+
+    assert tap003.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    env = environment_step(i=2, env=env)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+
+    env = environment_step(i=2, env=env)
+
+    # Testing that TAP003 Enters into the expected kill chain stages
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+
+    env = environment_step(i=2, env=env)
+
+    # Testing that the stage successfully impacted the simulation - User is logged in
+    # TODO: Add an assert for this.
+
+
+def test_tap003_kill_chain_stage_access():
+    """Tests the successful/failed handlers in the access stage in the InsiderKillChain"""
+    env = uc7_tap003_env()
+    tap003: TAP003 = env.game.agents["attacker"]
+
+    assert tap003.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    env = environment_step(i=2, env=env)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+
+    env = environment_step(i=2, env=env)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+
+    env = environment_step(i=2, env=env)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
+
+    env = environment_step(i=2, env=env)
+
+
+def test_tap003_kill_chain_stage_manipulation():
+    """Tests the successful/failed handlers in the manipulation stage in the InsiderKillChain"""
+
+    env = uc7_tap003_env()
+    env.reset()
+    tap003: TAP003 = env.game.agents["attacker"]
+
+    assert tap003.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
+
+    # Testing that the stage successfully impacted the simulation - Accounts Altered
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    st_intra_prv_rt_dr_1: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-DR-1")
+    assert st_intra_prv_rt_dr_1.user_manager.admins["admin"].password == "red_pass"
+
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    st_intra_prv_rt_cr: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-CR")
+    assert st_intra_prv_rt_cr.user_manager.admins["admin"].password == "red_pass"
+
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    rem_pub_rt_dr: Router = env.game.simulation.network.get_node_by_hostname("REM-PUB-RT-DR")
+    assert rem_pub_rt_dr.user_manager.admins["admin"].password == "red_pass"
+
+
+def test_tap003_kill_chain_stage_exploit():
+    """Tests the successful/failed handlers in the exploit stage in the InsiderKillChain"""
+
+    env = uc7_tap003_env()
+    tap003: TAP003 = env.game.agents["attacker"]
+    # The TAP003's Target Router/Firewall
+    st_intra_prv_rt_dr_1: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-DR-1")
+    st_intra_prv_rt_cr: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-CR")
+    rem_pub_rt_dr: Router = env.game.simulation.network.get_node_by_hostname("REM-PUB-RT-DR")
+    assert tap003.current_kill_chain_stage == BaseKillChain.NOT_STARTED
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.RECONNAISSANCE.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.PLANNING.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.ACCESS.name
+    assert tap003.next_kill_chain_stage.name == InsiderKillChain.MANIPULATION.name
+
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+    env.step(0)
+
+    assert tap003.current_kill_chain_stage.name == InsiderKillChain.EXPLOIT.name
+
+    # Testing that the stage successfully impacted the simulation - Malicious ACL Added:
+    for _ in range(32):
+        env.step(0)
+
+    # Tests that the ACL has been added and that the action is deny.
+    st_intra_prv_rt_dr_1_acl_list = st_intra_prv_rt_dr_1.acl
+    assert st_intra_prv_rt_dr_1_acl_list.acl[1].action != None
+    assert st_intra_prv_rt_dr_1_acl_list.acl[1].action == ACLAction.DENY
+
+    st_intra_prv_rt_cr_acl_list = st_intra_prv_rt_cr.acl
+    assert st_intra_prv_rt_cr_acl_list.acl[1].action != None
+    assert st_intra_prv_rt_cr_acl_list.acl[1].action == ACLAction.DENY
+
+    rem_pub_rt_dr_acl_list = rem_pub_rt_dr.acl
+    assert rem_pub_rt_dr_acl_list.acl[1].action != None
+    assert rem_pub_rt_dr_acl_list.acl[1].action == ACLAction.DENY
--- a/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_multiple_rules.py
+++ b/tests/e2e_integration_tests/threat_actor_profiles/test_tap003_multiple_rules.py
@@ -0,0 +1,201 @@
+# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK
+from typing import Protocol
+
+import pytest
+import yaml
+
+from primaite.config.load import _EXAMPLE_CFG
+from primaite.game.agent.scripted_agents.abstract_tap import (
+    AbstractTAP,
+    BaseKillChain,
+    KillChainOptions,
+    KillChainStageOptions,
+    KillChainStageProgress,
+)
+from primaite.game.agent.scripted_agents.TAP001 import MobileMalwareKillChain
+from primaite.game.agent.scripted_agents.TAP003 import InsiderKillChain
+from primaite.session.environment import PrimaiteGymEnv
+from primaite.simulator.network.hardware.nodes.network.router import ACLAction, Router
+from primaite.utils.validation.ip_protocol import PROTOCOL_LOOKUP
+from primaite.utils.validation.ipv4_address import IPV4Address
+from primaite.utils.validation.port import PORT_LOOKUP
+
+# Defining constants.
+ATTACK_AGENT_INDEX = 32
+START_STEP = 1  # The starting step of the agent.
+FREQUENCY = 2  # The frequency of kill chain stage progression (E.g it's next attempt at "attacking").
+VARIANCE = 0  # The timestep variance between kill chain progression (E.g Next timestep = Frequency +/- variance)
+REPEAT_KILL_CHAIN = False  # Should the TAP repeat the kill chain after success/failure?
+REPEAT_KILL_CHAIN_STAGES = False  # Should the TAP restart from it's previous stage on failure?
+KILL_CHAIN_PROBABILITY = 1  # Blank probability for agent 'success'
+RULES = [
+    {
+        "target_router": "ST-INTRA-PRV-RT-DR-1",
+        "position": 1,
+        "permission": "DENY",
+        "src_ip": "192.168.220.3",
+        "src_wildcard": "NONE",
+        "dst_ip": "192.168.220.3",
+        "dst_wildcard": "NONE",
+        "src_port": "ALL",
+        "dst_port": "ALL",
+        "protocol_name": "ALL",
+    },
+    {
+        "target_router": "ST-INTRA-PRV-RT-DR-2",
+        "position": 5,
+        "permission": "DENY",
+        "src_ip": "192.168.220.3",
+        "src_wildcard": "NONE",
+        "dst_ip": "ALL",
+        "dst_wildcard": "NONE",
+        "src_port": "ALL",
+        "dst_port": "ALL",
+        "protocol_name": "ALL",
+    },
+    {
+        "target_router": "ST-INTRA-PRV-RT-CR",
+        "position": 6,
+        "permission": "PERMIT",
+        "src_ip": "192.168.220.3",
+        "src_wildcard": "NONE",
+        "dst_ip": "ALL",
+        "dst_wildcard": "NONE",
+        "src_port": "ALL",
+        "dst_port": "ALL",
+        "protocol_name": "ALL",
+    },
+    {
+        "target_router": "REM-PUB-RT-DR",
+        "position": 3,
+        "permission": "PERMIT",
+        "src_ip": "192.168.220.3",
+        "src_wildcard": "0.0.0.1",
+        "dst_ip": "192.168.220.3",
+        "dst_wildcard": "0.0.0.1",
+        "src_port": "FTP",
+        "dst_port": "FTP",
+        "protocol_name": "TCP",
+    },
+    #
+]
+
+
+def uc7_tap003_env(**kwargs) -> PrimaiteGymEnv:
+    """Setups the UC7 TAP003 Game with the start_step & frequency set to 1 with probabilities set to 1 as well"""
+    with open(_EXAMPLE_CFG / "uc7_config_tap003.yaml", mode="r") as uc7_config:
+        cfg = yaml.safe_load(uc7_config)
+        cfg["io_settings"]["save_sys_logs"] = False
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["start_step"] = START_STEP
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["frequency"] = FREQUENCY
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["variance"] = VARIANCE
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["repeat_kill_chain"] = kwargs["repeat_kill_chain"]
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["repeat_kill_chain_stages"] = kwargs[
+            "repeat_kill_chain_stages"
+        ]
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["MANIPULATION"]["probability"] = kwargs[
+            "manipulation_probability"
+        ]
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["ACCESS"]["probability"] = kwargs[
+            "access_probability"
+        ]
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["PLANNING"]["probability"] = kwargs[
+            "planning_probability"
+        ]
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["EXPLOIT"]["malicious_acls"] = RULES
+        # Adding the new test target to TAP003's starting knowledge:
+        new_target_dict = {
+            "ST-INTRA-PRV-RT-DR-2": {
+                "ip_address": "192.168.170.2",
+                "username": "admin",
+                "password": "admin",
+            }
+        }
+        new_target_manipulation = {
+            "host": "ST-INTRA-PRV-RT-DR-2",
+            "ip_address": "192.168.170.2",
+            "action": "change_password",
+            "username": "admin",
+            "new_password": "red_pass",
+        }
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["PLANNING"]["starting_network_knowledge"][
+            "credentials"
+        ].update(new_target_dict)
+        cfg["agents"][ATTACK_AGENT_INDEX]["agent_settings"]["kill_chain"]["MANIPULATION"]["account_changes"].append(
+            new_target_manipulation
+        )
+    env = PrimaiteGymEnv(env_config=cfg)
+    return env
+
+
+def test_tap003_cycling_rules():
+    """Tests to check that TAP003 repeats it's kill chain after success"""
+
+    env = uc7_tap003_env(
+        repeat_kill_chain=True,
+        repeat_kill_chain_stages=True,
+        manipulation_probability=1,
+        access_probability=1,
+        planning_probability=1,
+    )
+    tap003: TAP003 = env.game.agents["attacker"]
+
+    def wait_until_attack():
+        for _ in range(120):
+            # check if the agent has executed and therefore moved onto the next rule index
+            env.step(0)
+            if tap003.history[-1].action == "node-send-remote-command":
+                if tap003.history[-1].parameters["command"][0] == "acl":
+                    return
+        pytest.fail("While testing the cycling of TAP003 rules, the agent unexpectedly didn't execute its attack.")
+
+    wait_until_attack()
+    target_node: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-DR-1")
+    assert (rule_0 := target_node.acl.acl[1]) is not None
+    assert rule_0.action == ACLAction.DENY
+    assert rule_0.protocol == None
+    assert rule_0.src_ip_address == IPV4Address("192.168.220.3")
+    assert rule_0.src_wildcard_mask == None
+    assert rule_0.dst_ip_address == IPV4Address("192.168.220.3")
+    assert rule_0.dst_wildcard_mask == None
+    assert rule_0.src_port == None
+    assert rule_0.dst_port == None
+
+    target_node: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-DR-2")
+    wait_until_attack()
+    assert (rule_1 := target_node.acl.acl[5]) is not None
+    assert rule_1.action == ACLAction.DENY
+    assert rule_1.protocol == None
+    assert rule_1.src_ip_address == IPV4Address("192.168.220.3")
+    assert rule_1.src_wildcard_mask == None
+    assert rule_1.dst_ip_address == None
+    assert rule_1.dst_wildcard_mask == None
+    assert rule_1.src_port == None
+    assert rule_1.dst_port == None
+
+    wait_until_attack()
+    target_node: Router = env.game.simulation.network.get_node_by_hostname("ST-INTRA-PRV-RT-CR")
+    assert (rule_2 := target_node.acl.acl[6]) is not None
+    assert rule_2.action == ACLAction.PERMIT
+    assert rule_2.protocol == None
+    assert rule_2.src_ip_address == IPV4Address("192.168.220.3")
+    assert rule_2.src_wildcard_mask == None  # default
+    assert rule_2.dst_ip_address == None
+    assert rule_2.dst_wildcard_mask == None  # default
+    assert rule_2.src_port == None
+    assert rule_2.dst_port == None
+
+    wait_until_attack()
+    target_node: Router = env.game.simulation.network.get_node_by_hostname("REM-PUB-RT-DR")
+    assert (rule_3 := target_node.acl.acl[3]) is not None
+    assert rule_3.action == ACLAction.PERMIT
+    assert rule_3.protocol == PROTOCOL_LOOKUP["TCP"]
+    assert rule_3.src_ip_address == IPV4Address("192.168.220.3")
+    assert rule_3.src_wildcard_mask == IPV4Address("0.0.0.1")
+    assert rule_3.dst_ip_address == IPV4Address("192.168.220.3")
+    assert rule_3.dst_wildcard_mask == IPV4Address("0.0.0.1")
+    assert rule_3.src_port == PORT_LOOKUP["FTP"]
+    assert rule_3.dst_port == PORT_LOOKUP["FTP"]
+
+    # If we've gotten this fair then we can pass the test :)
+    pass
				`@@ -0,0 +1 @@`
				`# © Crown-owned copyright 2025, Defence Science and Technology Laboratory UK`