The exploding dependency tree is top source of risk  & operational pain

This security issue gives an attacker the ability to exploit the Linux io_uring subsystem by crafting malicious submission queue entries, allowing them to evade traditional defenses. The following protection guardrails can further prevent the following steps an attacker can take: If the initial compromise or subsequent rootkit deployment occurs within a container, Container Drift Protection (Binaries & Scripts) helps prevent the execution of unauthorized tools or dropped components not present in the original image. Finally, if the installed components attempts to establish command and control by creating a reverse shell, Reverse Shell Protection detects and blocks the binding of shell input/output to a network socket. Therefore, BlueRock is not blind to io_uring-based attacks, when compared to other syscall-only based security solutions.

‍

• T1106: Native API: The article describes a technique where attackers exploit the io_uring asynchronous I/O framework to execute arbitrary code within the kernel context. This is a clear example of exploiting an Application Programming Interface (API) to perform actions that are not intended by the legitimate functionality of the API, specifically to execute malicious code in the kernel. This aligns with the MITRE ATT&CK Technique T1106: Execution through API.
• T1068: Exploitation for Privilege Escalation: The rootkit technique allows attackers to execute code within the kernel's address space by manipulating the io_uring submission queue. This indicates that the attackers are using the legitimate processing of I/O requests to execute their code, effectively abusing the kernel's normal operations to bypass security mechanisms. This is an example of Exploitation for Privilege Escalation, where attackers exploit vulnerabilities to gain higher privileges, in this case, kernel-level execution. This aligns with the MITRE ATT&CK Technique T1068: Exploitation for Privilege Escalation.
• T1211: Exploitation for Defense Evasion: The article mentions that the rootkit circumvents common kernel security defenses such as Kernel Page Table Isolation (KPTI) or Supervisor Mode Execution Prevention (SMEP). This implies a Security Feature Bypass, where the attacker specifically targets and bypasses security mechanisms designed to prevent unauthorized code execution in the kernel. This is consistent with the MITRE ATT&CK Technique T1211: Exploitation for Defense Evasion.
• T1564: Hide Artifacts: By operating within io_uring, the rootkit can potentially hide its activities from security tools that monitor traditional system call hooks or kernel module presence. This stealth capability is indicative of the rootkit's use of techniques to avoid detection, aligning with the MITRE ATT&CK Technique T1564: Hide Artifacts, which involves concealing malicious activity from security monitoring.

This security issue gives an attacker the ability to remotely execute code on vLLM deployments using the Mooncake feature by sending a specially crafted payload that exploits an unsafe deserialization process. The following protection guardrails can further prevent the following steps an attacker can take: Initially, an attacker would send malicious data designed to be processed by Python's pickle.loads() function; Python Deserialization Protection directly counters this by intercepting the deserialization attempt and applying security policies to block the execution of harmful function calls embedded within the attacker's payload, thus preventing the initial remote code execution. Should an attacker somehow achieve code execution and the malicious code attempts to run operating system commands for reconnaissance (like gathering system information using uname or whoami) or to manipulate files (such as compressing model data for exfiltration using tar), Python OS Command Injection Prevention would monitor the Python runtime and block these unauthorized OS command execution attempts. To establish persistent control, an attacker might then try to create a reverse shell, connecting the compromised system back to their command-and-control server; Reverse Shell Protection is designed to detect and prevent this by blocking attempts to bind shell file descriptors to network sockets. If the vLLM service is running in a containerized environment and the attacker, having gained code execution, attempts to download and run new tools not part of the original container image—such as a more robust backdoor, a network scanning utility to find other vulnerable hosts, or a data exfiltration tool like rclone—Container Drift Protection (Binaries & Scripts) would block the execution of these unauthorized binaries or scripts. Furthermore, if the attacker's code execution involves placing a malicious script or executable in a non-standard directory like /tmp and then attempting to run it, Process Path Exec Allow would intercept this execution attempt and block it if the path is not on an approved allowlist, preventing the attacker from running tools from unexpected locations.

• T1059.006: Command and Scripting Interpreter: Python: The vulnerability in vLLM via Mooncake integration allows attackers to execute remote code by exploiting an unsafe deserialization process. The use of pickle.loads() for deserializing network data is the core issue, which aligns with the MITRE ATT&CK technique for exploiting deserialization vulnerabilities to execute arbitrary code. This technique is identified as T1059.006 (Command and Scripting Interpreter: Python).
• T1590: Gather Victim Network Information: The article mentions that the Mooncake integration exposes sockets on all interfaces without network controls, allowing arbitrary users to send payloads to the affected service. This indicates a lack of proper network segmentation and filtering, which is relevant to the MITRE ATT&CK technique T1590 (Gather Victim Network Information) as attackers can exploit network configurations to identify vulnerable services.
• T1040: Network Sniffing: The network exposure of the Mooncake pipe using ZMQ over TCP suggests that attackers could potentially perform network sniffing or traffic analysis to gather information about the communication protocols and data being transmitted. This aligns with MITRE ATT&CK technique T1040 (Network Sniffing).
• T1570: Lateral Tool Transfer: The vulnerability allows for remote code execution on distributed hosts, indicating that attackers could use this to move laterally across the network. This aligns with the MITRE ATT&CK technique T1570 (Lateral Tool Transfer), as attackers could transfer tools or payloads across the network using the compromised service.

‍

This security issue gives an attacker the ability to execute arbitrary code remotely on vLLM instances due to insecure deserialization within the Mooncake integration. The following protection guardrails can further prevent the following steps an attacker can take: When an attacker sends a specially crafted serialized Python object to the vulnerable recv_pyobj() function, which then attempts to deserialize it using pickle.loads(), Python Deserialization Protection helps prevent the initial remote code execution by intercepting this deserialization process and restricting potentially harmful function calls embedded within the payload, such as those designed to initiate system commands or access sensitive files. If the attacker's code, perhaps through a partially successful deserialization, then attempts to execute operating system commands directly from within the Python environment, Python OS Command Injection Prevention would monitor and block these unauthorized system-level actions, for instance, preventing the execution of shell commands intended to download additional malware or exfiltrate data. To establish persistent control or interactive access after gaining an initial foothold, an attacker might try to set up a reverse shell; Reverse Shell Protection thwarts this by preventing the compromised process from binding shell input, output, and error streams to a network socket, thereby blocking the creation of such interactive command channels. In scenarios where the vulnerable vLLM service is running inside a container, and the attacker, having achieved code execution, attempts to introduce and run new malicious binaries or scripts that were not part of the original, trusted container image, Container Drift Protection (Binaries & Scripts) would block their execution, thus preserving the integrity of the containerized environment. Finally, should an attacker manage to place malicious tools or scripts in non-standard file system locations, such as temporary directories, and then attempt to execute them to further their attack, Process Path Exec Allow enforces execution policies based on pre-approved path allowlists, preventing these unauthorized programs from running from untrusted locations.

• T1203: Exploitation for Client Execution: The attacker exploits a vulnerability in the vLLM library's Mooncake integration, specifically targeting the insecure handling of serialized data in the recv_pyobj() function. This function uses pickle.loads() on data received over unsecured ZeroMQ sockets, which is a known method for Remote Code Execution (RCE) if the data is untrusted. The attacker can send malicious serialized data to trigger arbitrary code execution on the target system. This attack method aligns with MITRE ATT&CK Technique ID T1203, which covers exploitation for client execution, including exploiting software vulnerabilities to execute code remotely.
• T1059.006: Command and Scripting Interpreter: Python: The vulnerability involves the use of Python's pickle.loads() function on untrusted data, which is inherently insecure as it can deserialize data that leads to code execution. This aligns with MITRE ATT&CK Technique ID T1059.006, which covers the use of Python for execution. The attacker can craft serialized data that, when deserialized using pickle.loads(), executes arbitrary Python code.

‍

This security issue in PyTorch gives an attacker the ability to achieve remote code execution by tricking a system into loading a specially crafted malicious model file, even when developers use the weights_only=True setting in torch.load() which is typically considered a safer option. The following protection guardrails from BlueRock can further prevent the following steps an attacker can take: When the malicious model file is loaded and attempts to execute arbitrary commands through the vulnerable Python torch.load() function, Python OS Command Injection Prevention steps in to block these unauthorized OS commands directly within the Python process, preventing the initial code execution that could lead to system compromise. Should an attacker's initial payload, after bypassing the intended weights_only=True safeguard, attempt to run from an unexpected or temporary location on the system where the malicious model might have been saved, Process Path Exec Allow ensures that only applications from approved, legitimate paths can be executed, thereby stopping malware or unauthorized tools dropped in unusual directories from running. If the PyTorch application is running within a containerized environment, and the attacker, having achieved initial execution, tries to introduce new malicious binaries or scripts not part of the original trusted container image—for instance, to establish persistence or escalate privileges—Container Drift Protection (Binaries & Scripts) would prevent these unauthorized executables from running, maintaining the integrity of the container. Following a successful command execution, if the attacker attempts to establish a persistent, interactive connection back to their own server by initiating a reverse shell from the compromised machine to gain direct control, Reverse Shell Protection actively detects and blocks this common post-exploitation technique. Furthermore, if the attacker's executed code attempts to exfiltrate stolen data, such as sensitive model parameters or proprietary datasets, or tries to move laterally by connecting to other systems within the network (e.g., to access cloud metadata services for credentials or other internal AI development servers), Process Socket Deny restricts the compromised process from making unauthorized network connections, effectively containing the threat and preventing data breaches or further network compromise.

• T1059: Command and Scripting Interpreter: The article describes a vulnerability in the PyTorch framework, specifically in the torch.load() function when used with the parameter weights_only=True. This allows an attacker to execute arbitrary commands on the target machine, which is indicative of Remote Code Execution. The attacker can craft a model file designed to exploit this flaw, thereby achieving execution of commands remotely on the victim's system. This aligns with the MITRE ATT&CK technique for Command and Scripting Interpreter (T1059), as it involves executing commands on a system.
• T1204: User Execution: The article mentions that malicious actors can exploit the vulnerability by crafting a model file designed to exploit the flaw in the torch.load() function. This involves modifying or creating files to achieve execution of arbitrary commands. This aligns with the MITRE ATT&CK technique for User Execution (T1204), as it requires the user to load a malicious model file which then executes the attacker's code.
• T1570: Lateral Tool Transfer: The vulnerability allows for remote command execution, which can lead to data breaches, system compromise, or lateral movement in cloud-hosted AI environments. This suggests that an attacker could use this flaw to move laterally within a network or cloud environment after initial compromise. This aligns with the MITRE ATT&CK technique for Lateral Movement (T1570), as it involves moving through a network after gaining initial access.

‍

This security issue gives an attacker the ability to execute arbitrary code, alter data, or access sensitive information on systems running vulnerable NVIDIA TensorRT-LLM versions by exploiting improper pickle deserialization in the Python executor's Inter-Process Communication channel. The following protection guardrails can further prevent the following steps an attacker can take: When an attacker attempts to inject a malicious pickled object into the IPC channel, Python Deserialization Protection intercepts the deserialization process, applying security policies to restrict function calls from the deserialized object, thereby aiming to block the execution of malicious functions designed for arbitrary code execution or unauthorized data access before full impact. Should this initial payload attempt to execute operating system commands, for example, to gather system information or run further malicious scripts, Python OS Command Injection Prevention monitors the Python runtime environment and blocks these unauthorized command execution attempts. If the attacker's code then tries to establish a persistent command and control channel, Reverse Shell Protection prevents the binding of shell STDIN/STDOUT/STDERR to network sockets, effectively blocking reverse shell attempts. In scenarios where the vulnerable software runs within a container and the attacker tries to introduce new malicious binaries or scripts not part of the original image, such as a tool to escalate privileges, Container Drift Protection (Binaries & Scripts) would block their execution. Complementing this, Process Path Exec Allow prevents the execution of any attacker-introduced executables or scripts if they are saved to and run from non-allowlisted filesystem paths, like a temporary download folder. To counter data theft or unauthorized modification, if the malicious code attempts to read or alter files designated as sensitive, such as configuration files, private keys, or even the LLM's model weights, Sensitive File Access monitors and can block these unauthorized file operations. Finally, if the attacker attempts to exfiltrate stolen sensitive information by having the compromised TensorRT-LLM process initiate outbound network connections to an attacker-controlled server, or even attempts to download additional tools, Process Socket Deny can deny these socket operations if the process is not on an explicit allowlist for network activity.

• T1059.006: Command and Scripting Interpreter: Python: The vulnerability stems from the improper handling of Inter-Process Communication (IPC) within the Python executor component, specifically through the use of the Python 'pickle' module for serialization and deserialization of untrusted data. This technique of exploiting deserialization vulnerabilities is commonly associated with executing arbitrary code. Therefore, the attacker could exploit this vulnerability to execute arbitrary malicious code on the system, which aligns with the MITRE ATT&CK Technique T1059.006: Command and Scripting Interpreter: Python. This technique ID applies as the attacker leverages the Python environment to execute scripts or commands via deserialization attacks.
• T1003: OS Credential Dumping: A local attacker with access to the system could exploit this vulnerability to tamper with data or disclose sensitive information. The ability to tamper with data or disclose sensitive information falls under the MITRE ATT&CK Technique T1003: OS Credential Dumping, where attackers attempt to gain access to credentials and other sensitive information. Although the article doesn't explicitly mention credential dumping, the risk of sensitive information disclosure through IPC vulnerabilities suggests potential exposure of credentials.

‍

This security issue gives an attacker the ability to execute arbitrary code on a victim's system by tricking them into loading a specially crafted Keras model file, even with Keras's safe_mode enabled. The following protection guardrails can further prevent the following steps an attacker can take: When an attacker crafts a malicious .keras file with a manipulated configuration to specify arbitrary Python functions for execution upon model loading, Python Deserialization Protection helps prevent these malicious functions from being called and executed, thereby blocking the initial arbitrary code execution that occurs when the Model.load_model function processes the compromised configuration. Should this initial execution attempt to run further operating system commands, for instance, by using Python's os or subprocess modules to scan directories for sensitive data or execute reconnaissance tools, Python OS Command Injection Prevention steps in to block these unauthorized system-level commands. If the compromised Keras application is running within a container, and the attacker's code attempts to execute new scripts or binaries not originally part of the container image, such as downloading and running a second-stage payload like a Remote Access Trojan to establish persistence by creating a new scheduled task, Container Drift Protection (Binaries & Scripts) prevents these drifted executables from running. Finally, if the attacker, having gained code execution, attempts to establish a persistent command and control channel by initiating a direct socket connection back to their server to exfiltrate data or issue further commands, Reverse Shell Protection detects and blocks this malicious outbound connection, severing the attacker's remote access.

• T1203: Exploitation for Client Execution: The article describes a vulnerability in the Keras deep learning framework that allows for arbitrary code execution when a maliciously crafted model file is loaded. This is an example of the attacker exploiting a vulnerability to execute arbitrary code on the victim's system, which aligns with the MITRE ATT&CK technique for 'Exploitation for Client Execution'. The key aspect here is the exploitation of the Model.load_model function to execute code specified in a manipulated config.json file within a .keras archive.

‍

This security issue gives an attacker the ability to achieve remote code execution on servers running vulnerable BentoML versions by sending a specially crafted HTTP request that exploits an insecure deserialization flaw. The following protection guardrails can further prevent the following steps an attacker can take: Initially, when the attacker attempts to exploit the pickle.loads() function with a malicious payload by manipulating an HTTP request to omit buffer-lengths in the metadata, Python Deserialization Protection intercepts this deserialization process, applying policies to restrict harmful function calls from the deserialized object, thereby aiming to block the arbitrary code execution before it fully materializes on the server. Should the attacker's code, now running on the server, attempt to execute operating system commands for reconnaissance, such as trying to run find or grep to locate AI model files or API keys, Python OS Command Injection Prevention would detect and block these OS command execution attempts originating from the Python process. If the compromised application is running within a container and the attacker, after gaining initial execution, tries to download and run additional tools like network scanners or malware not present in the original container image, Container Drift Protection (Binaries & Scripts) would prevent the execution of these new, unauthorized binaries by maintaining a manifest of original executables. Furthermore, if the attacker's code attempts to execute any script or binary, including legitimate system tools used for malicious purposes like establishing a pivot point with socat, from a non-standard or unauthorized directory such as a temporary download folder, Process Path Exec Allow would block such execution by enforcing that processes only run from pre-approved filesystem paths. Finally, to prevent data theft or unauthorized modification, such as the attacker trying to read sensitive AI model files, configuration files containing credentials, or attempting to corrupt model files on disk to sabotage AI operations, Sensitive File Access monitors and can block these unauthorized access attempts to files designated as critical.

• T1203: Exploitation for Client Execution: The attacker can send malicious payloads via HTTP requests to exploit the deserialization flaw. This involves 'Exploitation for Client Execution' where the attacker sends data to a vulnerable server to trigger execution of arbitrary code. The article mentions that 'the payload content is sourced from an HTTP request, which can be fully manipulated by the attack.' This aligns with the technique of exploiting client-side vulnerabilities through crafted requests.

‍

How this security issue gives an attacker the ability to execute arbitrary code on AI inference servers by exploiting insecure deserialization in frameworks like Meta's Llama. The following protection guardrails can further prevent the following steps an attacker can take: An attacker first sends crafted malicious data, often containing a serialized payload, to a vulnerable network service like the exposed ZeroMQ socket used by the Llama Stack's Python Inference API. Upon receiving this data, the application improperly deserializes it using an unsafe method like Python's pickle, triggering remote code execution on the host machine. Should the attacker's code attempt to establish interactive command-line access back to their own machine by binding shell streams to the network socket, **Reverse Shell Protection** detects and blocks this common post-exploitation technique. Furthermore, if the attacker, having gained initial execution, tries to download or create new malicious tools, scripts, or binaries onto the compromised system and then run them to escalate privileges, exfiltrate data, or move laterally, Container Drift Protection (Binaries & Scripts) prevents the execution of these non-original files, effectively neutralizing the payload.

• T1203: Exploitation for Client Execution: The article describes a vulnerability in Meta's Llama framework that allows an attacker to execute arbitrary code by exploiting deserialization of untrusted data. This aligns with the MITRE ATT&CK technique for Exploitation for Client Execution (T1203), as the attacker can execute code by sending malicious data that is deserialized by the application.

• T1648: Serverless Execution: The article mentions that the vulnerability in the Llama framework involves the deserialization of untrusted data using the pickle library in Python. This is directly related to the MITRE ATT&CK technique for Insecure Deserialization (T1648), as the flaw is due to the unsafe handling of serialized data.

• T1021: Remote Services: The use of ZeroMQ sockets over the network, which could be exploited by attackers to send crafted malicious objects, indicates the technique of Remote Services (T1021). This is because the vulnerability allows remote code execution via network-exposed services.

• T1601: Modify System Image: The article discusses how Meta addressed the issue by switching from the pickle serialization format to JSON for socket communication. This reflects the technique of Update Software (T1601), where the vulnerability is mitigated by updating the software to use a safer serialization format.

• T1498: Network Denial of Service: The article also touches on a separate issue where OpenAI's ChatGPT crawler could be manipulated to initiate a distributed denial-of-service (DDoS) attack. This aligns with the MITRE ATT&CK technique for Network Denial of Service (T1498), as the vulnerability can be used to overwhelm a target site's resources.

While these Linux kernel eBPF vulnerabilities enable initial memory corruption through integer overflow errors, BlueRock's defense-in-depth approach significantly reduces their impact. These vulnerabilities may allow attackers to achieve initial memory corruption, but BlueRock's security mechanisms contain and mitigate the attack's progression in several key ways. Kernel Integrity Protection and Integrity Patch Violation prevent unauthorized modifications to kernel code segments, blocking attempts to inject malicious code following successful memory corruption. Process Credential Protection and DirtyCred Protection safeguard critical credential structures, preventing the privilege escalation paths that attackers typically pursue after exploiting kernel memory vulnerabilities. Privileged Inode Protection blocks attempts to modify sensitive filesystem objects and kernel interfaces that attackers frequently target to establish persistence. Register Protect helps maintain the integrity of CPU registers during exploitation attempts, potentially disrupting control flow hijacking techniques. Page Table Protection prevents attacks from escalating to compromise memory isolation mechanisms if attackers attempt to target page tables during later exploitation stages. This multi-layered approach ensures that even if an attacker successfully exploits the initial memory corruption vulnerability, BlueRock significantly restricts their ability to achieve meaningful objectives such as privilege escalation, persistent access, or data exfiltration.

‍

• T1068: Exploitation for Privilege Escalation: The article discusses two vulnerabilities, CVE-2024-56614 and CVE-2024-56615, in the Linux kernel's eBPF framework. Both vulnerabilities allow attackers to exploit integer overflow errors in critical functions, leading to out-of-bounds writes and memory corruption. This aligns with the MITRE ATT&CK technique for exploiting public-facing applications, as the vulnerabilities can be leveraged to gain control over the kernel. This is an example of Exploitation for Privilege Escalation, where the attacker uses a vulnerability to execute arbitrary code with elevated privileges.
• T1203: Exploitation for Client Execution: The vulnerabilities allow an attacker to perform an out-of-bounds write operation, which can lead to memory corruption and potential control flow hijacking. This action corresponds to the MITRE ATT&CK technique for hijacking execution flow through exploitation, as the attacker can manipulate the program execution flow to execute arbitrary code.
• T1068: Exploitation for Privilege Escalation: The successful exploitation of these vulnerabilities could lead to a complete system compromise, allowing the attacker to gain root privileges and execute arbitrary code. This scenario aligns with the MITRE ATT&CK technique for Privilege Escalation, where an attacker gains higher-level permissions on a system.‍

The Gafgyt malware attack begins with the exploitation of misconfigured Docker Remote API servers, allowing attackers to gain initial access and deploy malicious containers. BlueRock's Container Capability Control effectively mitigates this step by ensuring that only containers with specified capabilities are permitted to run, thereby preventing the deployment of unauthorized or malicious containers like those used in the Gafgyt attack. Once the container is deployed, the attacker attempts to escalate privileges by using 'chroot' and 'bind' to mount the host's root directory, potentially gaining control over the host system. BlueRock's Container Runtime Socket Protection (Available 2024 Dec) further secures this environment by restricting container capabilities, thus preventing unauthorized access to the host's filesystem and thwarting privilege escalation attempts. These mechanisms collectively ensure that the deployment and execution of malicious containers are effectively controlled and monitored, significantly reducing the risk of such attacks.

• T1133: External Remote Services: The attackers targeted misconfigured Docker Remote API servers to spread the Gafgyt malware. This indicates that the attackers gained initial access through exploiting external remote services that were improperly secured, allowing them to connect to and manipulate these services remotely.
• T1610: Deploy Container: The attackers deployed the Gafgyt malware by creating a Docker container using a legitimate 'alpine' docker image. This shows the use of the 'Deploy Container' technique, where the attacker utilizes containerization to execute their malicious payload.
• T1611: Escape to Host: The article mentions that the attacker used 'chroot' and 'Binds' to mount the host's root directory to the /mnt directory inside the container. This allowed the container to access and modify the host's filesystem, representing a privilege escalation through escaping the container to the host.
• T1059.004: Command and Scripting Interpreter: Unix Shell: The attackers downloaded the Gafgyt botnet binary as a file named 'rbot' and executed it. This action is an example of using a command and scripting interpreter, specifically a Unix shell, to execute commands on the compromised system.
• T1105: Ingress Tool Transfer: The article describes the attacker downloading the Gafgyt botnet binary from a remote location to the Docker container. This process involves transferring tools or payloads into a compromised environment, aligning with the 'Ingress Tool Transfer' technique.
• T1071: Application Layer Protocol: The Gafgyt malware communicates with a command-and-control server using hardcoded IP addresses and ports. This is indicative of the 'Application Layer Protocol' technique, where malware uses standard protocols to communicate with its C2 infrastructure.
• T1016: System Network Configuration Discovery: The Gafgyt malware performs a network discovery action by determining the local IP address of the victim host using Google's DNS server. This aligns with the 'System Network Configuration Discovery' technique, where the malware gathers information about the network interfaces and configurations.
• T1498: Network Denial of Service: The primary impact of the Gafgyt malware deployment is launching distributed denial-of-service (DDoS) attacks using various protocols like UDP, TCP, and HTTP. This represents the 'Network Denial of Service' technique, where the goal is to disrupt the availability of targeted systems or networks.

In the Earth Estries cyber intrusion campaign, the attackers initially exploited public-facing server vulnerabilities to gain access to Linux servers, deploying the MASOL RAT for persistent access. Once inside, they utilized the MASOL RAT to maintain a foothold within the compromised systems, targeting Southeast Asian government networks. BlueRock's Container Drift Protection (Binaries & Scripts) effectively mitigates this threat by ensuring that only authorized binaries and scripts from the original container image are allowed to execute. This mechanism prevents unauthorized modifications to system processes, thereby blocking the execution of malicious payloads like MASOL RAT, and maintaining the integrity of the server environment.

• T1190: Exploit Public-Facing Application: The Earth Estries group exploits public-facing server vulnerabilities to establish initial access. The article specifically mentions 'Earth Estries is aggressively targeting the public-facing servers of victims' and lists vulnerabilities like Ivanti Connect Secure VPN Exploitation, Fortinet FortiClient EMS SQL Injection, and ProxyLogon. This aligns with the MITRE ATT&CK technique for Exploit Public-Facing Application (T1190).
• T1021: Remote Services: After gaining initial access, the attackers used living-off-the-land binaries (LOLBINs) such as WMIC.exe and PSEXEC.exe for lateral movement within networks. This is described in the article as 'After gaining control of the vulnerable server, we observed that the attackers leveraged living-off-the-land binaries (LOLBINs) like WMIC.exe and PSEXEC.exe for lateral movement.' This corresponds to the MITRE ATT&CK technique for Lateral Movement via Remote Services (T1021).
• T1071: Application Layer Protocol: The Earth Estries group deploys malware like SNAPPYBEE, DEMODEX, and GHOSTSPIDER for espionage. The article mentions 'deployed customized malware such as SNAPPYBEE, DEMODEX, and GHOSTSPIDER to conduct long-term espionage activities.' This indicates the use of malware to maintain persistence and conduct operations, aligning with the MITRE ATT&CK technique for Command and Control via Application Layer Protocol (T1071).
• T1090.003: Proxy: Multi-hop Proxy: The attackers used a complex C&C infrastructure, which suggests sophisticated Command and Control operations. The article notes 'Earth Estries uses a complex C&C infrastructure managed by different teams,' which aligns with the MITRE ATT&CK technique for Multi-hop Proxy (T1090.003).
• T1014: Rootkit: The use of the DEMODEX rootkit by Earth Estries for long-term persistence is highlighted in the article: 'We found that they implanted the DEMODEX rootkit on vendor machines.' This corresponds to the MITRE ATT&CK technique for Rootkit (T1014).
• T1505.002: Server Software Component: Transport Agent: The Earth Estries group uses backdoors like GHOSTSPIDER, SNAPPYBEE, and MASOL RAT for persistent access. The article describes 'A key finding from our recent investigation is the discovery of a new backdoor, GHOSTSPIDER,' indicating the use of backdoors for persistence, aligning with the MITRE ATT&CK technique for Implant Internal Image (T1505.002).
• T1574.001: Hijack Execution Flow: DLL Search Order Hijacking: The attackers use 'DLL search order hijacking' as part of their GHOSTSPIDER infection flow, as noted in 'On the infected endpoint, the threat actor deploys a legitimate executable file alongside a malicious DLL file for DLL search order hijacking.' This aligns with the MITRE ATT&CK technique for Hijack Execution Flow: DLL Search Order Hijacking (T1574.001).
• T1059.001: Command and Scripting Interpreter: PowerShell: The attackers' use of PowerShell scripts for initial infection is described in the article: 'the attackers used another variant of DEMODEX... the first-stage PowerShell script requires a decryption key as an argument.' This corresponds to the MITRE ATT&CK technique for Scripting (T1059.001).

In the attack described, the vulnerability CVE-2024-47208 in Apache OFBiz allows attackers to exploit Groovy expressions through URL manipulation, leading to remote code execution. This is achieved by combining Server-Side Request Forgery (SSRF) and Code Injection flaws, enabling attackers to execute arbitrary code on the server. BlueRock's Container Memory Namespace Isolation mechanism effectively mitigates this threat by ensuring that the physical memory used by user-space applications is strongly isolated. This isolation prevents applications in one namespace from accessing memory in another, thereby thwarting any attempts at privilege escalation that could arise from such code execution vulnerabilities.

• T1203: Exploitation for Client Execution: The article describes how CVE-2024-47208 allows attackers to inject Groovy expressions through manipulated URLs, leading to remote code execution. This indicates the use of 'Exploitation for Client Execution' as attackers are exploiting the vulnerability to execute arbitrary code on the server. The relevant text is: 'This vulnerability stems from OFBiz’s handling of URLs, which allows remote attackers to inject Groovy expressions. By manipulating specific URLs, malicious actors can trigger the execution of arbitrary code on the server.'
• T1189: Drive-by Compromise: The article also mentions that CVE-2024-47208 involves a combination of Server-Side Request Forgery (SSRF) and Code Injection. SSRF is being used to access internal systems and services by exploiting how the server processes URLs. The relevant text is: 'This vulnerability arises from a combination of Server-Side Request Forgery (SSRF) and Code Injection flaws.'
• T1649: Steal or Forge Authentication Certificates: For CVE-2024-48962, the article explains that attackers can bypass SameSite protections to conduct Cross-Site Request Forgery (CSRF) attacks. This indicates the use of 'Cross-Site Request Forgery' where attackers craft malicious requests that appear to originate from the victim’s browser. The relevant text is: 'By exploiting this flaw, attackers can craft malicious requests that appear to originate from the victim’s browser, potentially leading to unauthorized actions and data breaches.'
• T1221: Template Injection: The article also mentions improper neutralization of special elements within OFBiz’s template engine as part of CVE-2024-48962. This points to 'Template Injection' where attackers inject malicious code into templates. The relevant text is: 'This vulnerability involves a combination of Code Injection, CSRF, and improper neutralization of special elements within OFBiz’s template engine.'

‍

The attacker began by exploiting exposed Docker daemons (T1190) using a script called "Docker Gatling Gun," deploying a container with malicious commands (T1059). Container Drift Protection (Binaries & Scripts) prevents the execution of unauthorized binaries and scripts, thus mitigating the deployment of the malicious container. Subsequently, the attacker used Sliver malware (T1211) for command and control (T1071.004, T1090), and to execute further commands (T1059). Container Drift Protection (Binaries & Scripts) again plays a crucial role by preventing the execution of any unauthorized binaries or scripts introduced by the malware. Finally, the attacker leveraged compromised Docker instances in a Docker Swarm (T1578.002) for persistence and to hijack resources (T1496) for cryptomining.

• T1190: Exploit Public-Facing Application: The attack gains initial access by exploiting exposed Docker daemons on ports 2375, 2376, 4243, and 4244. This is a well-known technique used to compromise systems that have publicly accessible services.
• T1059: Command and Scripting Interpreter: The initial script, TDGGinit.sh, is executed on compromised systems to launch subsequent malicious actions.
• T1578.002: Modify Cloud Compute Infrastructure: Create Cloud Instance: TeamTNT appends compromised Docker instances to a Docker Swarm, allowing them to persist in the environment as part of a larger cluster, ensuring continued access and control.
• T1211: Exploitation for Defense Evasion: TeamTNT uses Sliver malware, which replaces their previous Tsunami malware. Sliver is harder to detect and evades traditional detection methods by dynamically compiling with per-binary encryption keys.
• T1036: Masquerading: TeamTNT uses names like Chimaera and other familiar naming conventions to evade detection by masquerading as legitimate processes or infrastructure.
• T1014: Rootkit: We found the prochider rootkit ready to deploy in TeamTNT’s download server. They are known to use this in the past.
• T1552: Unsecured Credentials: TeamTNT deploys local searches for keys and credentials, such as SSH, cloud metadata server calls, etc., once they gain access.
• T1046: Network Service Discovery: TeamTNT uses tools like Masscan to aggressively scan the internet for exposed Docker daemons and other vulnerable systems, identifying additional targets.
• T1018: Remote System Discovery: The campaign involves local network scanning to find additional systems that can be compromised.
• T1102.001: Web Service: Dead Drop Resolver: TeamTNT uses Docker Hub and web servers as part of their infrastructure to store and distribute malware and to manage infected systems.
• T1071.004: Application Layer Protocol: DNS: TeamTNT’s use of Sliver malware supports DNS for Command and Control (C2) communication, in addition to HTTP(S) and mTLS.
• T1090: Proxy: Sliver supports WireGuard and other proxy techniques to tunnel C2 communications through legitimate channels, bypassing detection.
• T1496: Resource Hijacking: Running a cryptominer as part of the campaign or selling the computational power of their victims.

‍

The attack on exposed Docker Remote API servers began with the attackers probing for these vulnerable services, which allowed them to gain initial access. BlueRock's Container Capability Control effectively mitigates this step by securing external-facing remote services, preventing unauthorized access. Once access was gained, the attackers deployed a Docker container using a specific image, and executed a Base64 encoded payload. The payload attempted to escape the container using the 'nsenter' command to access the host's namespaces. BlueRock's Namespace Execution Guard is designed to prevent such container escape attempts, ensuring that even if a container is compromised, the host remains secure. These mechanisms collectively enhance the security posture against such sophisticated attacks by controlling container capabilities and preventing unauthorized namespace execution.

• T1133: External Remote Services: The attackers began their campaign by probing for exposed Docker Remote API servers. This technique is consistent with leveraging exposed remote services to gain initial access.
• T1610: Deploy Container: Once the attackers confirmed the presence of the Docker Remote API server, they created a Docker container using a specific image from Docker Hub. This technique involves deploying a container to execute further actions.
• T1059.004: Command and Scripting Interpreter: Unix Shell: After creating the Docker container, the attackers executed a Base64 encoded payload using the Docker Exec API. This technique involves using a command and scripting interpreter to execute malicious commands.
• T1611: Escape to Host: The payload attempted to escape the container by using the 'nsenter' command to enter the host's namespaces, which is indicative of a container escape technique.
• T1543.002: Create or Modify System Process: Systemd Service: The attackers created a systemd service for persistence if systemd was running in non-offline mode. This technique involves creating or modifying system processes to maintain persistence.
• T1053.003: Scheduled Task/Job: Cron: As a fallback persistence mechanism, the attackers set up a cron job, which is another method of maintaining persistence through scheduled tasks.
• T1036.005: Masquerading: Match Legitimate Name or Location: To avoid detection, the attackers named the container 'kube-edagent' to masquerade as a legitimate container, matching legitimate names or locations.
• T1082: System Information Discovery: The attackers gathered system information by checking for multiple running processes and active TCP connections, which is indicative of system information discovery.
• T1132.001: Data Encoding: Standard Encoding: The payload included a Base64 encoded shell script, which is a form of standard data encoding used to obfuscate the malicious commands.
• T1105: Ingress Tool Transfer: The attackers downloaded a malicious binary disguised as a PHP extension using a custom function, which is consistent with ingress tool transfer.

‍

The attack on CVE-2023-52447 begins with the exploitation of a use-after-free vulnerability in the Linux kernel's BPF subsystem, which is leveraged to orchestrate a race condition between two threads. This allows the attacker to modify kernel data structures, such as 'core_pattern', to achieve container escape. BlueRock's Core Pattern String Protection effectively mitigates this step by safeguarding the 'core_pattern' data structure from unauthorized modifications, thereby preventing the attacker from altering it to escape the container environment. This mechanism ensures that even if the vulnerability is exploited, the critical kernel data structures remain protected, maintaining the integrity of the container isolation.

• T1068: Exploitation for Privilege Escalation: The article describes a use-after-free vulnerability in the Linux kernel’s BPF subsystem, which can be exploited by orchestrating a race condition between two threads. This falls under the category of 'Exploitation for Privilege Escalation' as the attacker leverages the vulnerability to escape container isolation.
• T1190: Exploit Public-Facing Application: The article mentions that the PoC exploit is available on GitHub, which implies that the attackers could potentially use publicly available exploit code to achieve their objectives. This aligns with 'Exploit Public-Facing Application' where the attacker uses an existing exploit.
• T1611: Escape to Host: The vulnerability allows an attacker to modify kernel data structures, such as 'core_pattern', to achieve container escape. This involves manipulating the underlying system to gain higher privileges or escape restricted environments, which fits 'Escape to Host' technique.

‍

The attack initiated with the exploitation of a vulnerability in RocketMQ, allowing unauthorized command execution to gain initial access. BlueRock's Container Drift Protection (Binaries & Scripts) effectively mitigates this by preventing unauthorized executables and scripts from running, ensuring that only pre-approved binaries are executed. Once inside, the malware downloaded its main payload, which was then copied to a new location in the '/tmp' directory, a behavior characteristic of process masquerading. BlueRock's Linux/Host Drift Protection would detect such unauthorized changes to the system's file structure, alerting administrators to potential threats. The malware also employed rootkits to hide its presence and maintain persistence. BlueRock's Reverse Shell Protection prevents unauthorized attempts to bind shell input and output streams to network sockets, thereby blocking the malware's efforts to establish a backdoor for remote access. By leveraging these mechanisms, BlueRock provides comprehensive protection against the sophisticated tactics employed by the perfctl malware, ensuring system integrity and security.

• T1190: Exploit Public-Facing Application: The attack began with the exploitation of a vulnerability in RocketMQ (CVE-2023-33246), which allowed unauthorized command execution. This facilitated the initial access to the system.
• T1105: Ingress Tool Transfer: The malware then downloaded the main payload from an HTTP server controlled by the attacker, which is indicative of the use of a malicious download for initial infection.
• T1055.012: Process Injection: Process Hollowing: After downloading, the malware copied itself from memory to a new location in the '/tmp' directory, terminated the original process, and deleted the initial binary to cover its tracks. This behavior is characteristic of process injection and process masquerading.
• T1014: Rootkit: The malware employed rootkits to hide its presence, modifying the behavior of authentication mechanisms and preventing the recording of network traffic. This indicates the use of kernel module and user land rootkits.
• T1547.001: Boot or Logon Autostart Execution: Registry Run Keys / Startup Folder: To maintain persistence, the malware modified the ~/.profile script to execute itself during user login and copied itself to multiple locations with deceptive names.
• T1573.001: Encrypted Channel: Symmetric Cryptography: The malware utilized a Unix socket for internal communication and TOR for external communication, indicating the use of encrypted channels to evade network defenses.
• T1068: Exploitation for Privilege Escalation: For privilege escalation, the malware attempted to exploit the Polkit vulnerability (CVE-2021-4034).
• T1496: Resource Hijacking: The malware dropped a cryptominer and proxy-jacking software, indicating resource hijacking and unauthorized use of system resources.
• T1219: Remote Access Software: The malware opened a backdoor on the server and listened for TOR communications, which is indicative of the creation of a remote access tool (RAT).
• T1070.004: Indicator Removal: File Deletion: The malware deleted its binary after execution to avoid detection, which is a technique for defense evasion.
• T1071.001: Application Layer Protocol: Web Protocols: The malware used environment variables to store data that further affected its execution and behavior, showing an attempt to maintain persistence and evade detection.
• T1562.001: Impair Defenses: Disable or Modify Tools: The malware employed various methods to detect and terminate any competing malware, ensuring it maintained control over the infected system.
• T1027: Obfuscated Files or Information: The attacker utilized packed, stripped, and encrypted binaries to bypass defense mechanisms and hinder reverse engineering attempts.
• T1562.001: Impair Defenses: Disable or Modify Tools: The malware monitored for new user logins and suspended its activity to avoid detection, indicating the use of evasion techniques based on user activity.

‍

The attacker begins by exploiting the vulnerability in the nft_set_rbtree function of the Linux kernel, sending a specially crafted request to trigger a use-after-free condition. Following this, the attacker leverages the use-after-free condition to escalate privileges by modifying process credentials. BlueRock's Process Credential Protection is crucial here, as it prevents unauthorized privilege escalation by blocking attempts to overwrite process credentials with high-privileged values. Without BlueRock, the attacker attempts to gain full control over the system by chaining the initial exploit with subsequent attacks.

• T1190: Exploit Public-Facing Application: The attacker begins by exploiting a vulnerability within the Linux kernel, specifically targeting the nft_set_rbtree function. This function is responsible for managing sets in nftables. The vulnerability allows local authenticated attackers to obtain sensitive information by sending a specially crafted request. This corresponds to the technique of Exploiting Public-Facing Application.
• T1068: Exploitation for Privilege Escalation: Once the attacker has successfully triggered the vulnerability, they exploit the use-after-free condition in the nft_rbtree_gc_elem function. This condition occurs because the function lacks a crucial check, leading to memory that has been deallocated being inadvertently accessed. This can be classified under Exploitation for Privilege Escalation.
• T1005: Data from Local System: The attacker leverages the leaked information from the initial exploit to craft further attacks. By inserting a set element with specific flags and triggering an error condition, they cause a double deletion of a set element. This is a classic example of leveraging information disclosure to further exploit a system, aligning with Data from Local System.
• T1078: Valid Accounts: The attacker then escalates their privileges to root level by chaining the initial exploit with subsequent attacks. This allows them to gain full control over the affected system, fitting the technique of Privilege Escalation.

‍

The sedexp malware begins its attack by exploiting udev rules to maintain persistence on a Linux system. This allows the malware to execute malicious scripts whenever specific device events occur, such as when the /dev/random device is loaded. BlueRock's Container Drift Protection (Binaries & Scripts) can mitigate this by preventing unauthorized executables and scripts from running, ensuring that only binaries present in the original container image are executed. The malware also provides reverse shell capabilities, allowing attackers to maintain control over the compromised system. BlueRock's Reverse Shell Protection effectively counters this by blocking unauthorized attempts to bind shell input and output streams to network sockets, thus preventing reverse shell attacks. Additionally, the malware's potential to escape from a containerized environment is mitigated by BlueRock's Container Capability Control, which restricts container capabilities to prevent actions that could lead to container escapes, such as mounting the host filesystem or executing privileged commands. These mechanisms collectively enhance the security posture against the sophisticated tactics employed by sedexp.

• T1547.010: Boot or Logon Autostart Execution: Port Monitors: The initial compromise of the system is not explicitly described, but the article implies that the malware was able to get onto the system. This could have been through various means, but since it's not detailed, we start with the first clear technique: the malware achieving persistence through udev rules. 'Sedexp utilizes udev rules to maintain persistence.'
• T1053.005: Scheduled Task/Job: Scheduled Task: The udev rule ensures that the malware is run whenever /dev/random is loaded, which happens on every system reboot. 'This rule ensures that the malware is run whenever /dev/random is loaded. /dev/random is a special file that serves as a random number generator, used by various system processes and applications to obtain entropy for cryptographic operations, secure communications, and other functions requiring randomness.'
• T1219: Remote Access Software: The malware includes a reverse shell capability, allowing the attacker to maintain control over the compromised system. 'Reverse Shell Capability: It includes a reverse shell, allowing the threat actor to maintain control over the compromised system.'
• T1564.001: Hide Artifacts: Hidden Files and Directories: The malware modifies memory to hide any file containing the string 'sedexp' from commands like ls or find. 'Memory Modification for Stealth: The malware modifies memory to hide any file containing the string "sedexp" from commands like ls or find.'
• T1036.004: Masquerading: Masquerade Task or Service: The malware manipulates arguments to obfuscate its presence and changes the process name to blend in with legitimate system processes. 'Memory Allocation and Argument Handling: The malware manipulates arguments to obfuscate its presence. It changes the process name to kdevtmpfs using prctl to blend in with legitimate system processes.'
• T1547.010: Boot or Logon Autostart Execution: Port Monitors: The malware sets up persistence by copying itself to a specific location and creating a udev rule. 'Persistence Setup: The malware sets up persistence by copying itself to a specific location and creating a udev rule.'
• T1110.001: Brute Force: Password Guessing: The malware was used to hide credit card scraping code on a webserver, indicating a focus on financial gain. 'Credit Card Scraping: The malware was used to hide credit card scraping code on a webserver, indicating a focus on financial gain.'
• T1611: Escape to Host: The malware could theoretically be used to escape outside of a containerized workload.

‍

The Gafgyt malware variant begins its attack by brute-forcing weak SSH passwords to gain initial access to target machines. BlueRock's SSH Deep Auth & SSH Least Privilege mechanism effectively mitigates this step by enforcing strong authentication practices and limiting SSH access to only necessary users, thereby reducing the attack surface. Once access is gained, the attacker executes shell commands to prepare the server for further exploitation. Here, BlueRock's Container Drift Protection (Binaries & Scripts) comes into play by preventing unauthorized executables and scripts from running, thus blocking the execution of malicious binaries that are not part of the original container image. This mechanism ensures that any attempt to execute unauthorized code is thwarted, protecting the system from further compromise.

• T1110.001: Brute Force: Password Guessing: The attacker initially gained access to the target machine by brute forcing SSH credentials, which were weak. This is evident from the statement: 'In this attack we see a successful brute force attempt on our SSH honeypot which is configured with a very weak password.'
• T1059.004: Command and Scripting Interpreter: Unix Shell: Once access was gained, the attacker executed shell commands to inspect and prepare the server. This is shown in the article: 'Once access is gained a few commands to inspect and prepare the server are executed.'
• T1082: System Information Discovery: The attacker conducted system discovery to check if the machine was already infected and to identify any competing malware. This is highlighted by: 'A few checks are conducted mainly to determine if the machine has already been infected by this variant of Gafgyt and to check if another malware is running and if so to kill it.'
• T1055.001: Process Injection: Dynamic-link Library Injection: The attacker used two binaries that were executed in memory to avoid detection, as indicated by: 'Next the two binaries are executed in memory.'
• T1496: Resource Hijacking: The attacker executed a cryptomining operation using the XMRIG cryptominer, as described: 'Executing the cryptominer: Figure 4: Executing the XMRIG cryptominer.'
• T1490: Inhibit System Recovery: The attacker modified system configurations to optimize performance and security, such as altering the /etc/sysctl.conf file. This is noted in: 'Configuration alteration: Figure 6: Modifying configurations /etc/sysctl.conf.'
• T1070.003: Indicator Removal: Clear Command History: The attacker deleted history and log files to evade detection, as indicated by: 'Lastly history and logs files are deleted to evade detection.'
• T1036.005: Masquerading: Match Legitimate Name or Location: The attacker used masquerading techniques to make their binaries appear as legitimate system components, as noted: 'The names of these binaries indicate that the threat actors are putting emphasis on defense evasion as these names are masquerading as legitimate components related to the Linux operating system environment.'
• T1105: Ingress Tool Transfer: The attacker downloaded a brute force configuration file from a command and control (C2) server, as shown: 'The function backgroundlogic in the malware is set to download from the threat actor’s server (at 107.189.5.210) the file 1.txt, which is a brute force configuration file containing 179 sets of users and passwords.'

‍

The attack on the Argo CD Kubernetes controller begins with the exploitation of elevated permissions, allowing the attacker to manipulate the Redis caching server, which lacks password protection. This manipulation enables the attacker to alter application state manifests and trick Argo CD into accepting malicious updates. As the attacker deploys malicious pods with high privileges, BlueRock's Container Capability Control mechanism ensures that only containers with specified capabilities are allowed to run, effectively preventing the deployment of these potentially harmful containers. Furthermore, the attacker attempts to execute code on the host node by deploying a privileged pod. Here, BlueRock's Reverse Shell Protection mechanism comes into play by preventing unauthorized attempts to bind shell input and output streams to network sockets, thereby mitigating the risk of reverse shell attacks. These mechanisms collectively safeguard the Kubernetes environment from unauthorized container deployments and malicious script executions, maintaining the integrity and security of the cluster.

• T1068: Exploitation for Privilege Escalation: The article mentions that the attacker exploits the elevated permissions of the Argo CD server to escalate their privileges and potentially take control of the Kubernetes cluster. This indicates the use of privilege escalation techniques.
• T1600.001: Weaken Encryption: Reduce Key Space: The attacker manipulates the data stored in Argo CD’s Redis caching server, which lacks password protection. This involves altering application state manifests stored in the Redis server to exploit the system. This describes a manipulation of application state and configuration data.
• T1059: Command and Scripting Interpreter: The attacker uses the Argo CD server’s elevated permissions to deploy malicious pods with high privileges, which can execute code on the host node and access sensitive information. This demonstrates the use of deploying malicious code or scripts.
• T1114.002: Email Collection: Remote Email Collection: The attacker recalculates the hash for the manipulated manifest without a secret key, allowing them to modify the manifest data and present it as legitimate. This is indicative of the use of hashing algorithms to bypass integrity checks.
• T1610: Deploy Container: The attacker creates a low-privilege pod in another namespace to simulate a compromised pod within the cluster. This is a form of creating and using a container for malicious purposes.
• T1560.002: Archive Collected Data: Archive via Library: The attacker uses a Go program to decompress gzipped contents in the Redis server to uncover cached information about the applications managed by Argo CD, including their manifests and details about the Kubernetes cluster. This involves extracting and analyzing compressed data.
• T1057: Process Discovery: The attacker uses Redis profiler to observe interactions between pods and the Redis server to understand how application behavior is affected. This is a form of gathering information through monitoring and profiling.
• T1535: Unused/Unsupported Cloud Regions: The attacker modifies the application manifest in Redis and successfully deploys a privileged pod, which allows them to escalate privileges and execute code on the host node. This involves the manipulation of cloud infrastructure.
• T1021.004: Remote Services: SSH: The attacker adds their public SSH key to the node’s authorized keys, allowing them to connect to the node with an SSH shell. This is indicative of the use of SSH for remote access.

‍