Auditd Manager — CraftedSignal Threat Feed

Chroot Execution in Container Context on Linux

hello@craftedsignal.io — Sat, 02 May 2026 12:45:21 +0000

This detection rule identifies instances of the chroot command being executed within a Linux containerized environment. It leverages process execution telemetry from Elastic Defend and Auditd Manager to detect potential container escape attempts. The rule focuses on processes where the name is chroot or the command-line arguments contain chroot. Container context is determined by identifying processes with a title matching runc init, a container workload entry leader, or runc as the parent process. Successful container escapes can allow attackers to gain unauthorized access to the host system. The technique is often combined with sensitive host mounts, which are then leveraged after the chroot to access files and processes outside the container.

Attack Chain

An attacker gains initial access to a container, potentially through exploiting a vulnerability in the containerized application.
The attacker identifies sensitive host mounts within the container’s filesystem, such as /host, /proc/1/root, or other unexpected node paths.
The attacker executes the chroot command, specifying an alternate root filesystem, typically a host-linked mount.
The chroot command redirects system calls to the new root filesystem, effectively isolating the attacker from the container’s original environment.
The attacker leverages the new root filesystem to access files, directories, and processes on the host system outside the container’s boundaries.
The attacker may then attempt to escalate privileges by exploiting vulnerabilities in host system services or binaries.
The attacker may install malware or establish persistence mechanisms on the host system.
The attacker uses the compromised host system to pivot to other systems on the network or to exfiltrate sensitive data.

Impact

A successful container escape can lead to full compromise of the underlying host system, potentially impacting all containers running on the same host. This can enable attackers to access sensitive data, disrupt services, and move laterally within the network. In multi-tenant environments, a container escape can compromise the security of other tenants sharing the same infrastructure. A single successful container escape can lead to a widespread breach impacting numerous systems and applications.

Recommendation

Deploy the Sigma rule Chroot Execution in Container Context to your SIEM and tune for your environment.
Enable process execution telemetry from Elastic Defend and Auditd Manager on Linux to ensure the required data is available for detection.
Investigate any alerts generated by the Sigma rule to determine if the chroot execution was authorized and the target directory is an internal build root versus a host filesystem mount.
Monitor for follow-on shell execution, access to the container runtime socket, or kubelet credential paths, as these are common indicators of container escape attempts.

Potential Root Effective Shell from Non-Standard Path via Auditd

hello@craftedsignal.io — Fri, 01 May 2026 09:51:29 +0000

This detection identifies potential privilege escalation attempts on Linux systems by monitoring for processes with a root effective user ID (EUID) but a non-root real user ID (RUID), combined with the use of the -p flag (commonly used to preserve privileges in shells like bash or dash) and execution from a non-standard path (outside of /bin, /sbin, /usr/bin, etc.). Attackers may copy or link setuid-capable shells or similar helpers into writable locations to regain a root context after local exploitation. This behavior is often associated with post-exploitation activities where attackers attempt to maintain or regain elevated privileges. The rule relies on Auditd data to provide visibility into process execution events and user context. The original rule was published on 2026-04-24 by Elastic.

Attack Chain

Attacker gains initial access to the system with limited privileges (e.g., through exploiting a vulnerability or using stolen credentials).
Attacker identifies a writable directory outside of standard system binary paths (e.g., /tmp, /var/tmp).
Attacker copies or creates a symbolic link to a setuid-capable shell (e.g., /bin/bash, /bin/dash) into the identified writable directory. This copied shell retains the setuid bit.
Attacker executes the copied or linked shell from the non-standard path with the -p flag (e.g., /tmp/bash -p). The -p flag instructs the shell to preserve privileges, effectively running with the effective user ID (EUID) of root.
Auditd logs this process execution event, capturing the non-standard path, the use of the -p flag, the root EUID, and the non-root RUID.
The detection rule identifies the process execution event based on the criteria outlined above.
Attacker now has a root shell and can perform administrative tasks, install malware, or further compromise the system.

Impact

A successful privilege escalation attack can grant an attacker complete control over the compromised system. This allows them to access sensitive data, install malicious software, modify system configurations, and potentially pivot to other systems on the network. This can lead to data breaches, system downtime, and significant financial losses. The risk score for this type of activity is considered high due to the potential for significant impact.

Recommendation

Deploy the Sigma rule Potential Root Effective Shell from Non-Standard Path via Auditd to your SIEM and tune for your environment.
Ensure that Auditd Manager or Auditbeat is properly configured to collect process execution events with relevant fields (event.action, user.id, user.effective.id, process.args, and process.executable) as described in the rule setup to enable the rule to function correctly.
Investigate any alerts generated by this rule by inspecting process.executable, process.args, process.parent, and the full command line reconstructed in audit logs.
Regularly audit all setuid binaries on the filesystem to identify any unauthorized or malicious setuid executables.
Implement access controls and file integrity monitoring to prevent unauthorized modification of system binaries and writable directories.

Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket

hello@craftedsignal.io — Thu, 30 Apr 2026 16:24:01 +0000

CVE-2026-31431, dubbed Copy Fail, is a Linux kernel vulnerability that allows an attacker to write controlled bytes into the page cache of a readable file by abusing the authencesn AEAD path through AF_ALG and splice(). Public exploitation targets setuid-root binaries such as /usr/bin/su, then executes the corrupted in-memory copy to gain root. The vulnerability lies in the shared host page cache, making container-originated activity a possible node-compromise attempt. This exploit leverages the AF_ALG interface, which, while uncommon for unprivileged users, may be used in specific environments like kernel crypto testing or HSM integrations. Defenders should prioritize patching vulnerable kernels and restricting AF_ALG socket creation for untrusted workloads to mitigate this risk.

Attack Chain

An unprivileged user initiates multiple AF_ALG socket creation events (auditd.data.syscall == “socket” and auditd.data.a0 == “26”) or splice operations.
The attacker leverages the vulnerability to corrupt the page cache of a setuid-root binary, such as /usr/bin/su.
The attacker executes the targeted setuid-root binary (e.g., /usr/bin/su).
Due to the corrupted page cache, the executed binary behaves in an unexpected manner, leading to a privilege escalation.
The process transitions to a root UID, indicating successful privilege escalation.
A root shell is spawned, providing the attacker with elevated privileges.
The attacker performs actions requiring root privileges, such as creating persistence mechanisms or accessing sensitive credentials.
The attacker potentially compromises the entire host or node, especially in containerized environments.

Impact

Successful exploitation of CVE-2026-31431 leads to privilege escalation, allowing attackers to gain root access on the affected Linux system. This can result in complete system compromise, data exfiltration, and the ability to install malware or create persistent backdoors. In containerized environments, a compromised container can lead to node compromise, affecting other containers running on the same host. The vulnerability affects systems running vulnerable kernel versions, potentially impacting a wide range of servers and workstations.

Recommendation

Deploy the Sigma rule “Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket - Socket Creation Burst” to detect initial exploitation attempts based on AF_ALG socket activity.
Deploy the Sigma rule “Potential Copy Fail (CVE-2026-31431) Exploitation via AF_ALG Socket - Privilege Escalation” to detect privilege escalation attempts by monitoring executed processes with an effective user ID of root.
Immediately patch the kernel with the vendor fix for CVE-2026-31431 to eliminate the underlying vulnerability.
Until patching is possible, consider blocking algif_aead module loading or restricting AF_ALG socket creation via seccomp for untrusted workloads.
Add audit rules for socket, splice, and bind events as described in the rule’s Setup instructions to ensure comprehensive monitoring of AF_ALG related syscalls.

Curl or Wget Execution from Container Context

hello@craftedsignal.io — Tue, 23 Jan 2024 12:00:00 +0000

This detection rule identifies instances of curl or wget being executed from within containers managed by runc on Linux systems. The rule leverages Auditd Manager to monitor system calls and flags processes running with the title runc init that then execute curl or wget. This activity is noteworthy because attackers often use these tools to download malicious payloads (stagers, scripts, implants) or to exfiltrate data after compromising a container. While these tools can be used legitimately within containers, their execution in the context of runc init suggests a higher risk of malicious activity. The rule focuses on narrowing the signal to the container runtime boundary where unexpected download clients are more worthy of review. The rule specifically leverages Auditd Manager for data collection.

Attack Chain

An attacker gains initial access to a host system, possibly through exploiting a vulnerability in an application running outside the container (e.g., web application).
The attacker identifies a containerized application running on the compromised host.
The attacker exploits a vulnerability within the container, or abuses a privileged workload within the container, to gain elevated privileges or code execution within the container.
The attacker uses curl or wget to download additional tools or scripts into the container. These tools might include reverse shells, credential dumping tools, or data exfiltration utilities.
The attacker executes the downloaded tools to further compromise the container or the underlying host.
The attacker uses curl or wget to stage data for exfiltration to an external server. This may involve compressing and encoding data before transmission.
The attacker initiates the data exfiltration process using curl or wget to send the staged data to a remote server controlled by the attacker.
The attacker achieves their final objective, which could include data theft, system disruption, or further lateral movement within the network.

Impact

Compromised containers can lead to data breaches, service disruptions, and further attacks on internal systems. Successful exploitation could allow attackers to steal sensitive data, install malware, or pivot to other parts of the network, impacting confidentiality, integrity, and availability. The number of affected systems depends on the scope of the container deployment and the privileges granted to the compromised container.

Recommendation

Deploy the Sigma rule Detect Curl or Wget Execution from Container Context to your SIEM and tune for your environment.
Enable Auditd Manager with syscall coverage including execve to capture process execution and arguments within containers, as mentioned in the rule’s setup instructions.
Correlate alerts from this rule with network logs to identify the destination IP addresses and domains contacted by the compromised container.
Baseline trusted images and exclude stable image digests or namespaces when noisy to reduce false positives, as suggested in the rule’s false positives section.

Potential Privilege Escalation in Container via Runc Init

hello@craftedsignal.io — Fri, 05 Jan 2024 14:22:00 +0000

This detection identifies a potential privilege escalation vulnerability within container environments utilizing runc, the low-level container runtime used by Docker and containerd. The rule focuses on audit events triggered by runc init child processes. Specifically, it flags instances where the effective user ID is root (0), while the login user ID is not root. This discrepancy can indicate malicious activity, such as exploiting credential separation or namespace transitions to gain unauthorized root privileges within the container or escape to the host. This is relevant for defenders because a compromised container can lead to host compromise, data exfiltration, or denial of service.

Attack Chain

Attacker gains initial access to a container with limited privileges.
The attacker exploits a vulnerability within the container to execute code as the runc init process.
The runc init process spawns a child process while retaining a non-root user ID in audit telemetry.
The child process is assigned an effective user ID of 0 (root), bypassing normal permission controls.
The attacker leverages the elevated privileges to modify sensitive files or execute commands as root within the container’s namespace.
The attacker may then attempt to escape the container by exploiting kernel vulnerabilities or misconfigurations to gain access to the host system.
Upon gaining access to the host system, the attacker can install malware, steal sensitive data, or disrupt services.

Impact

A successful privilege escalation attack within a container environment can lead to complete compromise of the container and potentially the host system. This can result in data breaches, service disruptions, and unauthorized access to sensitive resources. The impact is significant because a single compromised container can become a launchpad for attacks against other containers or the underlying infrastructure.

Recommendation

Deploy the Sigma rule “Potential Privilege Escalation via Runc Init” to your SIEM to detect suspicious runc init process executions.
Enable Linux audit logging via the Auditd Manager integration, ensuring that execve and identity-related fields are captured.
Investigate any alerts generated by the Sigma rule by examining the full audit event details, including process ancestry, user IDs, and container metadata.
Review container configurations and security profiles to identify potential misconfigurations that could facilitate privilege escalation.
Implement network segmentation to limit the blast radius of a compromised container.

Unusual Process Connecting to Docker or Containerd Socket

hello@craftedsignal.io — Wed, 03 Jan 2024 12:00:00 +0000

This threat involves unauthorized processes connecting directly to container runtime sockets (Docker or Containerd) on Linux systems. This bypasses Kubernetes API server restrictions, potentially allowing attackers to create, execute, or manipulate containers without proper authorization or logging. The risk lies in attackers circumventing RBAC, admission webhooks, and pod security standards. The attack can start when a compromised process attempts to connect to the Docker or Containerd socket, potentially leading to privilege escalation and lateral movement within the containerized environment. This attack is significant because it undermines core security controls within container orchestration platforms.

Attack Chain

A malicious or compromised process gains initial access to the host system.
The process attempts to connect to the container runtime socket (e.g., /var/run/docker.sock or /run/containerd/containerd.sock).
The process bypasses the Kubernetes API server and associated security controls.
The attacker exploits the direct socket connection to create a new container.
The attacker gains access to sensitive data or resources within the container.
The attacker escalates privileges within the compromised container.
The attacker uses the compromised container to move laterally to other containers or hosts within the environment.
The attacker achieves their objective, such as data exfiltration or system compromise.

Impact

Successful exploitation allows attackers to bypass Kubernetes security measures, create unauthorized containers, and potentially gain control over the entire cluster. The observed impact includes privilege escalation, lateral movement, and data exfiltration. The severity of this attack depends on the level of access granted to the compromised container and the sensitivity of the data and resources within the cluster.

Recommendation

Enable Auditd Manager to capture network and socket events, specifically monitoring for connect calls to Unix sockets as described in the Auditd Manager documentation.
Deploy the Sigma rule “Unusual Process Connecting to Docker or Containerd Socket” to detect suspicious processes connecting to container runtime sockets, tuning process.executable and user.name for known legitimate processes.
Monitor file permissions on the socket paths (/var/run/docker.sock, /run/docker.sock, /var/run/containerd/containerd.sock, /run/containerd/containerd.sock) and restrict access to trusted groups only.