Incusd versions prior to 7.2.0 contain an argument injection vulnerability in the backup compression algorithm. The software only validates the first token of the compression algorithm against an allowlist but does not reject extra arguments, allowing an attacker to inject arbitrary command-line arguments. This can lead to arbitrary file writes on the host system and potentially arbitrary command execution.
A nil-pointer dereference vulnerability exists in the Incus daemon (incusd) in the function createDependentVolumesFromBackup. An authenticated user with can_create_instances permission can upload a specially crafted instance backup tarball containing malformed dependent volume entries with nil snapshot pointers or missing volume/pool fields. This causes the daemon to dereference nil pointers and crash, resulting in a persistent denial-of-service condition. The issue affects versions prior to 7.1.0 and was fixed in version 7.1.0.
Incusd's S3 protocol upload endpoint contains a path traversal vulnerability that allows an attacker to write arbitrary files on the host system. This occurs because the upload ID parameter is not sanitized before being appended to the uploads directory path. Exploitation can lead to arbitrary command execution by placing malicious files such as cron jobs on the host.
CVE-2026-48752 is a critical vulnerability in Incusd (github.com/lxc/incus) versions prior to 7.2.0 that allows arbitrary file read and write on the host via a maliciously crafted container image or instance backup containing a top-level 'templates' symlink. This can lead to arbitrary command execution on the host. The flaw arises because the tar extraction process does not reject a top-level 'templates' symlink, enabling attackers to map host directories and modify files such as cron jobs.
A vulnerability in Incusd prior to version 7.2.0 allows bypassing restricted project settings that block low-level container operations. Specifically, instance snapshots ignore the 'restricted.containers.lowlevel=block' setting, enabling an attacker to craft a malicious snapshot that executes arbitrary commands on the host with root privileges when restored. This flaw permits arbitrary command execution on the Incus server, leading to full compromise.
A vulnerability in Incusd prior to version 7.2.0 allows an attacker to write arbitrary files on the host via a crafted image containing a symlink named 'exec-output'. This symlink can redirect output files to arbitrary locations, enabling arbitrary command execution on the host. The flaw arises because the 'record-output' parameter writes command output to the 'exec-output' directory without sanitizing symlinks. This issue is fixed in version 7.2.0.
CVE-2026-48749 is a critical vulnerability in Incusd (github.com/lxc/incus/v7/cmd/incusd) versions prior to 7.2.0. A specially crafted container image containing a malicious rootfs symlink can be used to read and write arbitrary files on the host filesystem with root privileges. This occurs because Incusd processes a duplicate top-level rootfs symlink that can point to the host root, allowing arbitrary file access and potential command execution on the host. The vulnerability is fixed in version 7.2.0.
A path traversal vulnerability exists in the Mattermost Go module github.com/mattermost/mattermost/server/public versions prior to 0.1.22. The flaw allows attackers to manipulate API route paths by injecting crafted IDs containing path traversal sequences, redirecting API calls to unintended endpoints. This vulnerability is identified as CVE-2026-13426 and has been assigned a medium severity rating with a CVSS score of 5.4.
CVE-2026-13218 is a vulnerability in KubeVirt's virt-handler network cache handling where the WriteToCachedFile function lacks symlink protection. This allows a user with access to the virt-launcher container to plant a symlink that causes virt-handler to overwrite arbitrary host files with JSON content and change ownership. Exploitation requires non-default network configuration (bridge-type binding), exec access to the virt-launcher container, and is constrained by SELinux policies and content format limitations. The vulnerability is rated medium severity with a CVSS score of 4.2.
CVE-2026-13318 is a server-side request forgery (SSRF) vulnerability in KubeVirt's virt-api port-forward handler. The flaw arises because virt-api uses an IP address reported by the QEMU guest agent inside a VirtualMachineInstance (VMI) without validation. For VMIs using non-masquerade network bindings (bridge or secondary-only), this IP is fully controllable by the VM owner. An attacker with kubevirt.io:edit permissions can exploit this to create a VM that reports an arbitrary IP, enabling port-forward requests to establish TCP tunnels to arbitrary internal or external network destinations, bypassing NetworkPolicy isolation. The issue affects versions prior to 1.10.0-rc.0 and has been fixed starting with 1.10.0-rc.0. The vulnerability has a CVSS 3.1 score of 6.4 (medium severity).
CVE-2026-13322 is a vulnerability in KubeVirt's downward metrics virtio-serial server where the server reads guest requests without length limits or read deadlines, allowing a VM guest user to cause unbounded memory allocation in the virt-handler process. This can lead to the virt-handler being OOM-killed, disrupting management operations on the affected node. The vulnerability requires explicit configuration of the downward metrics virtio-serial device and is limited in scope to the node running the affected virt-handler pod. The impact is low as running VM workloads continue unaffected and recovery is possible by deleting the offending VirtualMachineInstance.
A vulnerability in Rekor's Alpine APK parsing logic allows unauthenticated attackers to cause an out-of-memory (OOM) condition by submitting specially crafted gzip-compressed payloads. The decompression process does not limit the total decompressed size, enabling a decompression bomb that can exhaust server memory and crash the service. This affects versions from 0.3.0 up to but not including 1.5.2. A fix is available in version 1.5.2.
The go-chi/chi v5 middleware RealIP is vulnerable to IP spoofing because it trusts the first IP in the X-Forwarded-For header without verifying the proxy chain. This allows attackers to bypass IP-based access controls and rate limiting by spoofing their IP address. The vulnerability affects versions up to v5.2.1 and is fixed in v5.3.0.
## Summary
`parseEfiSignatureList()` in `attest/internal/events.go` does not skip
`SignatureHeaderSize` vendor bytes before reading `EFI_SIGNATURE_LIST`
signature entries, violating UEFI specification section 31.4.1.
## Impact
For `hashSHA256SigGUID` lists, attacker-controlled vendor header bytes are appended directly to the trusted SHA256 hash list. A crafted TPM event log can inject arbitrary SHA256 hashes into the verifier's trusted measurement database, allowing a remote attestation verifier to accept a compromised boot state as legitimate — breaking the core integrity guarantee of remote attestation.
## Root Cause
After `binary.Read(&signatures.Header)` reads 28 bytes, `buf` points to the start of the `SignatureHeaderSize` vendor bytes. Both entry loops start at `sigOffset := 0` instead of `sigOffset := SignatureHeaderSize`, causing vendor bytes to be read as signature entries.
## Affected versions
All versions through commit `f877374` (2026-05-15).
## Fix
Pull request: https://github.com/google/go-attestation/pull/502
- Add bound check: `SignatureHeaderSize` must not exceed remaining list space
- Skip `SignatureHeaderSize` bytes before both entry loops
- Regression test: `TestParseEfiSignatureListNonZeroSignatureHeaderSize`
Gophish versions up to 0.12.1 contain a denial of service vulnerability that allows authenticated users with the User role to exhaust server memory by uploading a specially crafted Office document as an email template attachment. The vulnerability arises because the ApplyTemplate() function processes Office documents as ZIP archives and reads all contained files without size restrictions, enabling a zip bomb payload to consume excessive memory and crash the process.
An issue was discovered in Canonical ADSys upstream versions through v0.16.2. During Active Directory Certificate Services (AD CS) certificate auto-enrollment via the vendored Samba client script (internal/policies/certificate/python/vendor_samba/gp/gp_cert_auto_enroll_ext.py), ADSys utilizes a plaintext HTTP connection (http://) instead of a secure HTTPS connection (https://) to request the CA certificate from the Active Directory Certificate Services server (GetCACert). An unauthenticated network attacker positioned between the managed Ubuntu host and the configured AD CS CA hostname can conduct a Man-in-the-Middle (MITM) attack. By intercepting the plaintext HTTP request, the attacker can supply an arbitrary, attacker-controlled Root CA certificate. Because the system automatically accepts this certificate and registers it into the local system trust store via update-ca-certificates, this results in system-wide trust store poisoning. Consequently, TLS clients utilizing the operating system trust store on the affected machine will accept rogue certificates for arbitrary domains, enabling persistent decryption and interception of subsequent TLS connections. This issue is resolved in version v0.16.3.
The public dashboard query endpoint does not limit request body size before processing, allowing unauthenticated attackers to trigger excessive memory allocation by sending arbitrarily large JSON payloads. This can lead to denial of service through memory exhaustion. No valid dashboard access token or authentication is required to exploit this vulnerability.
The Loki datasource plugin's callResource handler contains a path traversal vulnerability. An authenticated Viewer-role user can escape the plugin's resource sandbox and access administrative Loki endpoints (e.g. /config, /services, /ready) to extract sensitive backend configuration and internal service information.
The Tempo and Loki datasource plugins construct backend HTTP requests by interpolating user-supplied input into URL paths without sanitization, enabling path traversal. A Viewer-role user can: (1) capture admin-configured datasource credentials (secureJsonData custom headers) by traversing to an attacker-controlled endpoint, (2) invoke state-changing admin endpoints on Tempo (e.g. /flush, /shutdown), and (3) exfiltrate internal service data via Loki's CallResource which returns full HTTP response bodies.
OpenShift Virtualization is Red Hat's virtualization solution designed for Red Hat OpenShift Container Platform.
This advisory contains OpenShift Virtualization v4.21 images.