Improper control of code generation in the agent import functionality of Amazon Bedrock AgentCore Starter Toolkit before 0.3.14 might allow an authenticated same-account actor to execute arbitrary code when a user imports and runs or deploys a Bedrock Agent, via crafted configuration values incorporated into generated Python source without safe literal encoding.
To remediate this issue, users should upgrade to version 0.3.14. Because this issue persists into generated source, upgrading alone is not sufficient: agents imported with an affected version must be re-imported with version 0.3.14 or later and their local and deployed output artifacts replaced.
A vulnerability in SSSD when configured to use Microsoft Entra ID allows local users to submit crafted lookup requests that are not properly sanitized. This can manipulate directory query filters and lead to unauthorized information disclosure. The flaw affects multiple specific versions of SSSD. The vulnerability has a medium severity rating with a CVSS score of 5.3.
CVE-2026-104046 is a vulnerability in the System Security Services Daemon (SSSD) on Red Hat Enterprise Linux 10. When Identity Provider (IdP) authentication is enabled, pre-authentication requests retain state in memory indefinitely without being cleared or timed out. A local attacker with access to the PAM authentication interface can repeatedly initiate authentication flows without completing them, causing unbounded memory consumption. This can lead to denial of service (DoS) by degrading or terminating SSSD authentication services. The vulnerability does not allow unauthorized access, data exposure, or privilege escalation.
CVE-2026-76061 is a vulnerability in CRI-O's bind_mount_prefix handling that allows a malicious container or local attacker to exploit an intermediate absolute symlink in a hostPath. This can cause the bind mount source to resolve outside the intended root prefix, potentially enabling unauthorized file access or privilege escalation on the host system. The issue affects multiple versions of CRI-O prior to fixed releases. A fix is available in CRI-O versions 1.34.14, 1.35.9, 1.36.6, and 1.37.1.
Uncontrolled search path element in CredentialProvider in Google Chrome on on Windows prior to 155.0.8059.39 allowed a local attacker to potentially execute arbitrary code outside the sandbox via a local program. (Chromium security severity: Low)
Dell System Update versions prior to 2.3.0.0 contain an incorrect permission assignment vulnerability that allows a low privileged local attacker to potentially elevate their privileges. This vulnerability is identified as CWE-732 and has a high severity rating with a CVSS score of 8.2. Exploitation requires local access and user interaction. No patch information is currently provided.
A vulnerability in sssd allows a local user to cause a Denial of Service (DoS) by exhausting the responder service's file descriptors. This is done by opening many concurrent connections to a responder socket, triggering an unthrottled retry loop that leads to high CPU usage and service stalls. The issue prevents legitimate identity and authentication requests from being processed. The CVSS score is 4.7, indicating medium severity. Multiple specific versions of sssd are affected as listed. No known exploits are reported in the wild, and no patch information is provided in the source data.
## Summary
A crafted ZIP-compressed OpenEXR image can return stale memory from a prior
ImageSharp operation as decoded pixels. The ZIP decoder accepts a non-empty
inflate result shorter than the EXR block's required size, then the EXR decoder
reads the full expected block.
This is a process-local, cross-operation information-disclosure defect. It is
relevant when an application uses the shared `Configuration.Default` allocator
for separate image operations and exposes pixels or output derived from a later
attacker-controlled EXR decode. Whether that creates a network attack path
depends on the host application.
No active exploitation is known.
## Affected package and versions
- Package: `SixLabors.ImageSharp` (NuGet)
- Affected published releases: **4.0.0, 4.1.0, and 4.1.1**
- Affected range: `>= 4.0.0, <= 4.1.1`
- Commit `0815358f9202a78bc7f3b83e19282dc3654b500f` corresponds to release **v4.1.1**.
EXR support first appears in v4.0.0. The cross-operation PoC exposes the prior-operation marker on each published 4.x release, while the full-inflate control does not expose it on any of them.
## Details
For ZIP/ZIPS EXR compression, [`ExrDecoderCore`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/ExrDecoderCore.cs#L169-L205)
allocates the expected block buffer without `AllocationOptions.Clean` and later
interprets the complete buffer as channel data. [`ZipExrCompression`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/Compression/Decompressors/ZipExrCompression.cs#L25-L38)
accepts a partial but non-empty inflate result: [`UndoZipCompression`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Formats/Exr/Compression/ExrBaseDecompressor.cs#L45-L75)
rejects only `totalRead == 0`.
Only the returned prefix is reconstructed and interleaved into the destination
block. The remaining bytes retain allocator contents from a completed prior
operation. `ExrDecoderCore` then converts those bytes into returned image
pixels.
## Reproduction
The attached Docker PoC uses the published `SixLabors.ImageSharp` NuGet package
version 4.1.1. It first completes a valid 64x1 FLOAT/ZIPS EXR encoding that
contains the test value `0.27182817`. It then decodes a separate crafted 256x1
FLOAT/ZIPS EXR.
The exploit payload inflates to 8 bytes although the declared image block needs
1024 bytes. The control payload inflates to all 1024 bytes. The marker is
present only in exploit output.
```sh
docker build -t imagesharp-4q3p-poc .
docker run --rm imagesharp-4q3p-poc exploit
docker run --rm imagesharp-4q3p-poc control
```
Test environment: Docker with `mcr.microsoft.com/dotnet/sdk:8.0`, .NET SDK
8.0.424 / .NET 8, Debian 12, Linux ARM64.
Observed output:
```text
imagesharp-assembly=4.0.0.0 informational-version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f
mode=exploit
prior-operation=valid-exr-encode-completed bytes=383
prior-value=0.27182817
leaked=True first-prior-value-pixel=4
imagesharp-assembly=4.0.0.0 informational-version=4.1.1+0815358f9202a78bc7f3b83e19282dc3654b500f
mode=control
prior-operation=valid-exr-encode-completed bytes=383
prior-value=0.27182817
leaked=False first-prior-value-pixel=-1
```
## Suggested remediation
Reject ZIP/ZIPS EXR blocks unless the decompressor produces exactly the expected
uncompressed byte count. Clearing the destination buffer is defense in depth,
but exact-length validation is required before parsing any decompressed bytes.
### Complete PoC files
Program.cs:
```csharp
using System.Buffers.Binary;
using System.Globalization;
using System.IO.Compression;
using System.Reflection;
using System.Text;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.Formats.Exr;
using SixLabors.ImageSharp.Formats.Exr.Constants;
using SixLabors.ImageSharp.PixelFormats;
// This performs two independent completed ImageSharp operations in one process.
// The first is a valid EXR encoding containing a test value. The second is a
// malformed EXR decode whose short ZIP result exposes that value from the
// allocator shared through Configuration.Default.
internal static class Program
{
private const int PriorWidth = 64;
private const int AttackerWidth = 256;
private const float PriorValue = 0.271828182f;
private static int Main(string[] args)
{
bool exploit = args.Length == 0 || args[0] == "exploit";
if (args.Length > 0 && args[0] is not ("exploit" or "control"))
{
Console.Error.WriteLine("usage: final-4q3p [exploit|control]");
return 2;
}
Assembly imageSharp = typeof(Image).Assembly;
string informationalVersion = imageSharp
.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
.InformationalVersion
?? "(missing)";
Console.WriteLine($"imagesharp-ass
Quasar Framework is a framework for building high-performance Vue.js user interfaces. Prior to @quasar/ssl-certificate 2.1.0, @quasar/cli 5.0.4, and @quasar/app-vite 3.3.0, the @quasar/ssl-certificate utility cached a combined private key and certificate PEM without explicitly applying owner-only filesystem permissions. Another local user able to read the cache can copy the key and impersonate a development TLS endpoint in an environment that trusts the certificate. The generated certificate was also CA-capable, carried unnecessarily broad key usages, and encoded the IPv6 loopback address as a DNS subject alternative name. This issue is fixed in @quasar/ssl-certificate 2.1.0, @quasar/cli 5.0.4, and @quasar/app-vite 3.3.0.
### **Impact**
An unauthenticated attacker who knows an account’s email address or username could trigger Payload’s account lockout mechanism and prevent that user from signing in.
You are affected if:
* Using an affected Payload version with an auth-enabled collection that uses local authentication and account lockout.
Applications that do not use Payload local authentication are not affected.
### **Patches**
Successful password resets now clear the account’s lockout state. The forgot-password flow also enforces a configurable minimum interval between reset emails, which defaults to 15 seconds.
Users should upgrade Payload packages to `>= 3.90.0` or `>= 4.0.0-canary.34`.
Multiple security vulnerabilities have been identified in OpenSSH as packaged in Red Hat Enterprise Linux 10.0 Extended Update Support. These include local man-in-the-middle attacks on X11 forwarding, client-side denial of service due to double free errors, sftp client file location control, brute-force attack facilitation, sshd security bypasses, scp file misplacement, and information disclosure via use-after-free. These issues affect both the OpenSSH client and server components. Red Hat has released an important security update addressing these vulnerabilities.
### Impact
When generating an API plugin manifest from an attacker-controlled or compromised OpenAPI description, Kiota copies `x-ai-capabilities.response_semantics.oauth_card_path` into the manifest without validating that it is a safe package-relative file reference. An attacker can supply parent-directory traversal, rooted paths, or absolute URIs instead of a card file within the plugin package.
The unsafe reference is propagated into the generated manifest. Its security effect depends on the downstream host's handling of the reference when the plugin is packaged and deployed. This is not local code execution or a file read performed by Kiota merely during generation. A consuming host that resolves the untrusted reference can cross the intended package boundary or use an unintended authentication card.
### Affected versions
The affected NuGet packages are `Microsoft.OpenApi.Kiota` and `Microsoft.OpenApi.Kiota.Builder`, starting with version 1.25.1, which introduced this manifest field. The field remains unvalidated through version 1.34.1, including the separate 1.29.1 security-backport release. Version 1.35.0 fixes the issue.
### Patches
Upgrade to Kiota 1.35.0 or later and regenerate affected plugin manifests. Kiota now applies the existing safe-file-reference validator to `oauth_card_path`, drops unsafe references, and emits a warning. Valid relative card paths remain supported.
- Fix: https://github.com/microsoft/kiota/pull/8055
- Fixed release: https://github.com/microsoft/kiota/releases/tag/v1.35.0
### Workarounds
Generate plugins only from trusted, integrity-protected OpenAPI descriptions. Before packaging or deployment, review generated manifests and remove any `oauth_card_path` that is not a safe relative reference confined to the plugin package. Do not rely on validation of sibling manifest fields to validate this field.
### Related advisories
GHSA-4jwf-m4wg-8p66 and GHSA-p5rm-jg5c-8c77 cover `static_template.file`. Their fixes do not enforce validation at the separate `oauth_card_path` emission site.
CVE-2026-104853 is a path traversal vulnerability in the nx tool's migrate command. It occurs because the migration file path from a package manifest is not validated, allowing extraction outside the intended temporary directory. This can lead to attacker-controlled file writes or truncation of files writable by the user, potentially enabling code execution if critical files are overwritten. The vulnerability affects nx versions from 13.10.0 up to but not including 22.7.10, and from 23.0.0 up to but not including 23.2.1. Most users running nx migrate normally are not exposed because the tool fetches and runs the latest patched nx version. Exposure occurs only if the local vulnerable nx version is forced to run. A fix is available in versions 22.7.10 and 23.2.1. No known exploitation in the wild has been reported.
CVE-2026-104041 is a vulnerability in the System Security Services Daemon (SSSD) on Red Hat Enterprise Linux 10. It allows an unprivileged local user to cause the negative cache in the Name Service Switch (NSS) responder to grow without bounds by repeatedly requesting lookups for nonexistent entries. This can exhaust memory resources, leading to a denial of service (DoS) where the responder becomes unresponsive or terminates. The vulnerability affects local authenticated users and does not allow remote exploitation or compromise of system confidentiality or integrity.
CVE-2026-104035 is a vulnerability in the SSSD Kerberos Credential Manager (KCM) responder on Red Hat Enterprise Linux 10. A local user can cause a denial of service by maintaining a persistent connection and repeatedly storing and destroying credentials, which leads to continuous memory consumption growth. This memory exhaustion renders the KCM responder unresponsive but does not affect data confidentiality, integrity, or elevate privileges. Mitigation involves disabling the KCM responder if not needed or restricting local access to the KCM UNIX socket. No official fix has been released yet.
CVE-2026-104032 is a vulnerability in SSSD on Red Hat Enterprise Linux 10 where an unprivileged local user can trigger repeated master automount map updates via the autofs responder due to missing authorization checks. This causes global cache invalidation and forces repeated backend directory lookups, resulting in denial of service through degraded automount availability and increased resource consumption. The issue only affects systems with SSSD automount integration enabled and accessible to untrusted local users. Red Hat rates this as a moderate severity local denial of service vulnerability without confidentiality or integrity impact.
CVE-2026-104031 is a moderate severity vulnerability in SSSD on Red Hat Enterprise Linux 10 where memory allocated during autofs responder service requests is not released until the client connection closes. A local attacker with access to the autofs responder socket can maintain an open connection and repeatedly submit valid requests, causing memory exhaustion and denial of service. The autofs responder is not enabled by default and must be explicitly configured. Mitigation involves disabling the autofs responder if not needed or restricting access to trusted clients. Restarting or stopping the responder reclaims memory but is an operational workaround rather than a fix.
Docling simplifies document processing by parsing diverse formats and providing integrations with the generative AI ecosystem. From 2.82.0 until 2.118.1, HTMLBackendOptions(render_page=True) permits file URLs because HTMLDocumentBackend._get_browser_request_block_reason does not enforce the enable_local_fetch setting or confine local requests to the source document directory. Crafted path-backed HTML can embed a readable local text file in a browser-rendered page image when Playwright is installed. Only filesystem Path inputs are affected because stream inputs use an opaque origin, and the default configuration, command-line interface, docling-serve, and non-rendering backends are not affected. This issue is fixed in 2.118.1.
Mercusys AC12 V2 contains a vulnerability where a hardcoded 512-bit RSA private key allows a local attacker to execute arbitrary code. This issue is identified as CVE-2026-78861 and has a high severity rating with a CVSS score of 7.7. The vulnerability requires local access and does not require user interaction. No patch or remediation information is currently provided.