OmniRoute versions 3.8.0 through 3.8.51 contain a vulnerability that allows holders of manage- or admin-scoped API keys or oma_ access tokens to change the management password without providing the current password. This can enable attackers to lock out the legitimate operator, take over dashboard login, or disable the login requirement entirely.
On September 6, 2026, an unidentified operator exfiltrated approximately 68.8 GiB of database backups from a Philippine government agency responsible for overseas employment and migrant workers. The stolen data included 27 SQL Server backups related to case management systems such as POEA and OFW variants. The operator inadvertently exposed their staging infrastructure through an open HTTP directory on a VPS in Singapore, revealing tools including a rebranded GodPotato privilege escalation tool (Wrqsnx), PowerShell stagers, and the Impacket toolkit. The attack leveraged DCOM and RPC mechanisms to gain SYSTEM-level access without exploiting known vulnerabilities. Certificate analysis linked the compromised infrastructure to the Philippine Overseas Employment Administration portal farm. Initial access methods and command-and-control channels remain unknown, though the tooling was deployed on agency portal hosts.
Eclipse ioFog Operator versions 3.8.0 up to but not including 3.9.2 disable TLS certificate verification when communicating with the Controller API and logging into an external OIDC issuer. This allows an on-path attacker to present any certificate, potentially capturing sensitive credentials such as the OAuth client secret or the Controller bootstrap admin password. The vulnerability was fixed in version 3.9.2.
A critical SQL injection vulnerability (CVE-2026-114625) in Arista Networks' VeloCloud Orchestrator (VCO) allows remote attackers with authenticated access to escalate privileges to operator level and access internal functionality not intended for remote use. The flaw affects on-premises VCO versions prior to 5.2.3.18, 6.1.3.10, and 6.4.2.12. Arista has patched the vulnerability and already mitigated hosted deployments. Attackers have actively exploited this zero-day, and administrators are urged to update immediately and monitor for suspicious activity.
OpenRemote versions from 1.2.0 up to but not including 1.31.0 have a missing authorization vulnerability in the GatewayServiceResource. This flaw allows any authenticated user, without requiring administrative privileges, to start, stop, and query gateway tunnels. Exploitation involves sending POST or DELETE requests to the gateway tunnel endpoint, enabling attackers to open persistent bidirectional TCP circuits into an edge gateway's network or to tear down operator tunnels.
CVE-2026-110744 is a vulnerability in the Red Hat Multicluster Global Hub operator where overly broad RBAC permissions allow cluster-wide impersonation of arbitrary users, groups, and service accounts. This flaw enables an attacker who compromises the operator or its service account credentials to escalate privileges and gain full administrative control over the Kubernetes cluster. Exploitation requires initially high privileges to breach the operator deployment or steal credentials. No effective mitigation or patch currently meets Red Hat's criteria for ease of use and stability.
In Eclipse ioFog Controller versions 3.8.0 through 3.9.1, operator WebSocket upgrades on the exec and log routes do not verify the bearer JWT. The payload is decoded and its groups or roles are used as RBAC subjects. A self-minted token whose groups contain admin matches the built-in admin role, with no account and no RoleBinding. The attacker can open an exec or log session for a microservice or fog whose UUID they already know. HTTP routes are not affected: they verify the token before RBAC. Agent WebSockets verify the fog token and are not affected.
CVE-2026-105949 is an improper authentication vulnerability in Cruise Control for Apache Kafka. The Jetty ConstraintSecurityHandler registers security constraints on exact path specs without a catch-all wildcard and does not deny uncovered HTTP methods. This allows requests with extra path segments to bypass authentication and access all 15 admin endpoints without authorization. In Red Hat AMQ Streams deployments, network policies restrict access to port 9090 to operator pods, reducing the effective severity. The vulnerability is rated high severity with a CVSS score of 8.8. A fix is available in Cruise Control version 3.1.0.
CVE-2026-12660 is a path traversal vulnerability in the IBM MQ Operator's Web Console that allows an authenticated administrator to write files outside the intended directory due to improper path validation. This flaw affects multiple versions of IBM MQ Operator prior to version 3.4.0, where it has been fixed. The vulnerability has a low CVSS score of 2.7 and does not impact confidentiality or availability but may allow limited integrity impact. No known exploits are reported in the wild.
KEDA versions 2.20.2 and earlier contain a critical improper privilege management vulnerability. A namespace administrator can exploit this by creating TriggerAuthentication and ScaledObject resources that cause KEDA to send the operator pod's ServiceAccount token to a malicious Vault endpoint. This allows the attacker to gain the operator's cluster-wide permissions, including broad secret access and workload control. The issue is fixed in version 2.21.0.
The insights-runtime-extractor runs as a privileged DaemonSet (`hostPID: true`)
that scans container processes for runtime fingerprinting. When scanning a
container, the coordinator:
1. **fork()s** a child process
2. **setns()** into the target container's PID and mount namespaces
3. **fchdir()** back to an orphaned FD pointing at the extractor's own root
filesystem (where `/crio.sock` is hostPath-mounted)
4. Calls **only `seteuid(target_uid)`** — changing the effective UID but leaving
the **real UID and saved-set-UID at 0** and **retaining the permitted
capability set**
5. The `check_no_privileged_perms()` guard inspects only the Effective capability
set (so it passes), and is **skipped entirely when the target runs as uid 0**
6. The `VersionExecutable` fingerprint invokes `fpr_kind_executable` with
`process.command_line[0]` — the target's argv[0], read from
`/proc/<pid>/cmdline` and **fully controlled by the workload**
7. `fpr_kind_executable` calls `exec.Command(executable, "--version").Output()`
— executing the **workload's own binary** inside the workload's mount
namespace while **ruid=0 in the host user namespace**
The executed process can call `setuid(0)` to restore full root with
`CAP_SYS_ADMIN`, and inherits the orphaned cwd which resolves into the extractor
container's filesystem containing the host CRI-O socket.
## Affected Code
### 1. Insufficient privilege drop (Rust — extractor coordinator)
**File:** `extractor/src/insights_runtime_extractor.rs`
```rust
// Lines 139-146 — seteuid-only drop, guard skipped for root containers
join_process_namespaces(process.pid)?;
change_dir(current_dir);
switch_user(*process.uid)?;
if *process.uid != 0 {
perms::check_no_privileged_perms()
.expect("Must not have privileged permissions to run fingerprints");
}
fingerprint::run_fingerprints(&config, out_dir, &process);
```
```rust
// Lines 182-185 — only effective UID changed; ruid/suid stay 0
fn switch_user(uid: u32) -> Result<(), ScannerError> {
debug!("... Becoming user: {uid}");
seteuid(uid.into()).map_err(|e| ScannerError::Errno(e))
}
```
### 2. Execution of untrusted binary (Go — fingerprint)
**File:** `fingerprints/pkg/utils/file.go`
```go
// Lines 75-80 — executes a path taken verbatim from workload's argv[0]
func GetExecutableVersionOutput(executable string) (string, error) {
out, err := exec.Command(executable, "--version").Output()
if err != nil {
return "", err
}
return string(out), nil
}
```
### 3. Workload-controlled path forwarded (Rust — version_executable)
**File:** `version_executable.rs`
```rust
// Lines 29-34 — workload-controlled command_line[0] forwarded to fingerprint
return Some(vec![
fpr_kind_executable,
out_dir.to_string(),
String::from(&process.command_line[0]),
String::from(&version_executable.runtime_kind_name),
]);
```
## Attack Pattern
**Attacker:** Any tenant able to schedule a pod (unprivileged, any namespace)
**Victim:** The node running the insights-runtime-extractor DaemonSet
**Trigger:** Automatic — the DaemonSet scans all container processes on the node
**Attack sequence:**
1. Attacker creates a pod whose process name matches a configured
versioned-executable pattern (`node`, `python`, `python3`, `MainThread`,
or contains `java`)
2. The pod's main binary (at the path matching argv[0]) is a malicious
executable that calls `setuid(0)` to restore root
3. When the insights operator triggers a scan, the DaemonSet forks, enters the
attacker's mount namespace, and executes the attacker's binary with ruid=0
4. The attacker's code regains full root with `CAP_SYS_ADMIN` in the host user
namespace
5. The inherited cwd contains the host CRI-O socket → full node compromise
A vulnerability in the Windows Machine Config Operator (WMCO) for Red Hat OpenShift Container Platform allows a compromised Windows worker node with WICD credentials to escalate privileges to cluster-administrator by submitting a specially crafted Certificate Signing Request (CSR). This flaw affects OpenShift clusters running WMCO with Windows nodes and can lead to full cluster takeover. No mitigation or workaround is currently available, but a product release 10.20.2 addresses related issues.
CVE-2026-101295 is a path traversal vulnerability in the oc-mirror tool used in Red Hat OpenShift Container Platform 4.13. The flaw occurs during operator catalog image extraction when tar entries are extracted without validating that file paths remain within the intended destination directory. This allows a malicious or compromised operator catalog image to write arbitrary files on the administrator's workstation with the privileges of the oc-mirror process.
Grav is a flat-file CMS. In versions 2.0.19 through 2.0.24 — and in 2.0.0 through 2.0.18 and 1.7.x only where content Twig has been explicitly enabled — page content authored by a user holding only page-write permission is rendered through a Twig sandbox that allowlists get_cookie(), which returns any cookie sent with the current request, including the visitor's session cookie. Because the read occurs server-side via filter_input(INPUT_COOKIE, ...), the HttpOnly, Secure and SameSite attributes offer no protection. Grav then stores the finished post-Twig output in a page-content cache keyed only on page identity and the configuration checksum, with no session, user or request dimension and no bypass for authenticated visitors. A page published by a page-write user can therefore capture the session identifier of the next administrator who views it, after which the cached output serves that identifier to unauthenticated visitors, who can replay the cookie to authenticate as that administrator. Since 2.0.19, security.twig_content.process_enabled defaults to true and Security::applyTwigContentDefault() derives each page's process.twig flag from that gate, so content Twig runs on every page with no frontmatter or operator action. Fixed in 2.0.25; 1.7.x is outside the backport scope.
Grav CMS 2.0.14 through 2.0.24 contains a privilege escalation vulnerability in the group and account blueprints. The access map is gated by a `security@: admin.super` guard that is resolved by the field's exact path, so a submitted flat dot-notation key such as `access.admin.super` (instead of the nested `access[admin][super]`) matches no blueprint rule, survives BlueprintSchema::filterArray() and flattening, and is written by FlexObject::update() via setNestedProperty(), which splits on `.` and reconstructs the nested value. An authenticated backend operator using the flex accounts backend who holds admin.users but not admin.super can therefore grant admin.super to their own account or to a group they belong to and escalate to full super-admin, gaining control over configuration, plugin and theme installation, the file manager, and all accounts. Fixed in 2.0.25, which drops any dotted key whose ancestor path is disabled or marked validate.ignore.
OpenClaw (npm package 'openclaw') before 2026.7.1 does not enforce the administrator scope requirement on browser control when it is reached through the node.invoke method, although direct browser.request access requires administrator scope. In Gateway deployments that honor caller identity and narrower operator scopes, a write-scoped caller with access to a connected browser-capable node can inspect pages, navigate tabs, or interact with browser-visible applications without the configured admin requirement; practical impact depends on the browser profile and signed-in state. Shared-secret token and password callers are considered fully trusted operators under OpenClaw's security model and are not affected. The issue is fixed in 2026.7.1.
OpenClaw (npm package 'openclaw') before 2026.7.1 incorrectly trusts requester provenance in message.action. In identity-bearing Gateway deployments (authentication modes that honor caller identity and narrower operator scopes), a write-scoped caller can supply another sender's identifier to the channel authorization checks and invoke a channel action under that spoofed requester identity, reaching operations the channel adapter would have denied to the real caller. Practical impact depends on the enabled channel, the action, and the target account's permissions. Shared-secret token and password callers are full trusted operators under OpenClaw's security model and are out of scope. The issue is fixed in 2026.7.1; as a workaround, restrict message.action to administrators and disable sensitive channel actions that rely on requester identity.
OpenClaw (npm package `openclaw`) before 2026.7.1 fails to restrict owner-only infrastructure tools exposed through the chat.send endpoint. In Gateway deployments using authentication modes that honor caller identity and narrower operator scopes, a write-scoped non-owner caller can start a chat turn whose tool inventory includes the `gateway` and `cron` tools, causing the agent to invoke owner-only configuration or scheduling operations, including persistent state changes. Practical impact depends on the tools selected by the model and the caller's ability to steer the turn. Shared-secret token and password callers are treated as fully trusted operators under OpenClaw's security model and are outside the scope of this issue. The issue is fixed in 2026.7.1; as a workaround, restrict chat.send to administrators in identity-bearing deployments and remove `gateway` and `cron` from affected agent tool policies.