In Eclipse Mosquitto versions 2.1 through 2.1.2, a listener configured with `protocol websockets` mishandles empty WebSocket data frames. `net__read_ws()` in `lib/net_ws.c` returns the number of framing bytes consumed (the 4 masking-key bytes) for a data frame with a zero-length payload, without writing any bytes to the caller’s buffer. The MQTT packet reader in `packet__read_single()` (`lib/packet_mosq.c`) trusts that return value as a payload byte count. A remote client can therefore advance the read position over an uninitialised heap allocation, causing the broker to process and forward uninitialised heap memory (information disclosure, including heap and libc pointers), and can underflow the unsigned `to_process` counter so that subsequent attacker-controlled frame data is written past the end of the allocation (heap out-of-bounds write). The out-of-bounds write is reachable from the CONNECT packet before any authentication check, so an unauthenticated client can corrupt the heap and crash the broker even when `allow_anonymous false` is set. Combining the disclosure and the write allows remote code execution as the broker’s user by any client able to establish a session.
mail-parser is a tool that parses emails by enhancing the Python standard library and extracting message details into a comprehensive object. From 4.6.0 until 4.6.3, write_attachments() calls _safe_attachment_filename() and write_sample() without isolating failures for individual attacker-controlled MIME parts. An RFC 2231 filename containing a NUL, a basename exceeding NAME_MAX, or an undecodable base64 payload can raise ValueError, OSError, or binascii.Error and abort the entire save loop. Later attachments remain unwritten; when a caller catches only MailParserError, the failure is not surfaced through the expected library-exception path. If a downstream scanner or sandbox reads only the extraction directory, a payload after the crafted part can be missed even though it remains in the delivered message, and the aborted batch also causes availability loss. This issue is fixed in version 4.6.3.
@fastify/busboy is a streaming parser for multipart form data used by Fastify. In versions 3.2.1 through 3.2.5, the parser can interpret the same multipart bytes differently depending on how they are split across socket reads: when the sequence that terminates a part's header block arrives split exactly at the configured header size limit, an off by one error drops the final header line, so a part declared as a binary file attachment is emitted as an ordinary text field instead of a file. A remote client controls both the multipart body and the header padding needed to reach the boundary and can influence segmentation, so an application that applies upload validation such as malware scanning or extension checks only to file events while trusting plain field values may process the payload through the wrong path. The parser level type confusion is fully reproducible, while the downstream validation bypass depends on the application. The issue is fixed in @fastify/busboy 3.2.6, which tracks how many terminator bytes were actually buffered when the limit is reached so a split terminator no longer corrupts the final header, and users should upgrade to 3.2.6 or later. As a workaround, apply the same validation to field values as to file uploads rather than treating file events as a trust boundary.
RBH Access Technologies Integra32 Security Management System 5.1.11 R5.0 contains an unauthenticated deserialization vulnerability in its deprecated .NET Remoting service, exposed on TCP port 2001 via the AxcvcLt.dll library using BinaryServerFormatterSinkProvider at TypeFilterLevel.Full without requiring authentication. A remote unauthenticated attacker can send a malicious serialized gadget payload (such as a ysoserial.net TypeConfuseDelegate chain) to the IntegraURI object endpoint, or exploit MarshalByRefObject/MarshalByValue unmarshalling for arbitrary file read/write and SMB/NTLMv2 credential coercion, to achieve remote code execution as NT AUTHORITY\SYSTEM and fully compromise the host.
The rainbowcolors package on PyPI, version 0.1.0, masquerades as an ANSI-color helper but downloads and executes a malicious binary on Windows systems. Upon the first use of any color method, it fetches an executable from an anonymous file-sharing URL, saves it to a temporary folder, and runs it detached from the console. It also modifies Microsoft Defender settings to exclude the drop folder and executable from antivirus scanning, facilitating stealthy execution of the malicious payload.
BITTER is a cyberespionage group targeting South Asian government, energy, and engineering sectors using a custom remote access trojan called PapRAT. PapRAT is deployed through multiple infection chains involving malicious LNK files, VHDX disk images with MSI installers, and URL shortcuts combined with WebDAV. The malware exists in C++ and Rust variants, with capabilities such as command execution, file and directory manipulation, screenshot capture, and secondary payload delivery. Persistence is maintained via scheduled tasks, and communication with command-and-control servers occurs over HTTP. The Rust variant adds enhanced features including PowerShell execution and sleep commands.
The npm package '@iobandamwer/cache-helper' is a malicious package masquerading as a cache utility. It contains no source code but includes prebuilt native binaries that execute a hidden payload during installation. This payload writes an opaque file to a temporary location, makes it executable, and runs it detached from the install process. The package includes extensive evasion techniques to detect CI environments, sandboxes, debuggers, and containerized environments, indicating it is designed to avoid analysis. Any system with this package installed should be considered fully compromised, and all secrets on that system should be rotated immediately.
The postcss-semantic-themes npm package contains malicious code that executes obfuscated JavaScript modules and includes native binaries performing extensive environment fingerprinting to evade analysis. It masquerades as a CSS theming kit but instead acts as a staged supply-chain malware payload, including brandjacking of the legitimate tailwindcss package name. Installation of this package compromises the host system, potentially exposing all stored secrets and keys.
CVE-2026-93849 is a vulnerability in Mattermost versions 11.7.0 through 11.7.10, 11.8.0 through 11.8.5, 11.9.0 through 11.9.1, and 11.10.0 through 11.10.1. The issue arises from a failure to apply allocation limits in the WebSocket msgpack decoder's byte-string decode paths. This allows an authenticated remote attacker to cause excessive server memory allocation by sending a crafted binary WebSocket frame with a Bin32 payload length up to 4,294,967,295 bytes. The vulnerability has a CVSS 3.1 base score of 6.5, indicating medium severity, and impacts availability without affecting confidentiality or integrity.
The npm package dsh-plugin-blender-3d version 0.2.1 contains a malicious postinstall script that downloads and executes a payload installing an XMRig cryptocurrency miner and persistent backdoors. The malware installs systemd units or cron jobs for persistence and mines Monero using a hardcoded wallet. If run with root or passwordless sudo, it achieves full persistent agent installation with stealthy system-component-like binaries and relay/tor channels. The package is considered fully compromising to any host where installed.
The net-codec-testmetest npm package version 1.0.1 contains malicious code that abuses the node-gyp build process to execute an obfuscated payload during installation. This payload decrypts and decompresses an embedded binary, which is then executed under the Bun runtime. The package serves as a dropper with no legitimate functionality, designed to stealthily execute arbitrary code on the host system.
The npm package 'log-rotate-testmetest' version 1.0.1 contains malicious code embedded in its binding.gyp file that triggers execution of an obfuscated payload during installation. This payload uses multiple layers of obfuscation including ROT cipher, AES-128-GCM decryption, and brotli decompression, ultimately executing attacker-controlled code via the Bun runtime. The package declares Bun as a runtime dependency to route execution through an alternate runtime rather than Node.js. There is no legitimate native build rationale for this behavior, indicating deliberate malicious intent.
The npm packages pixel-map-testmetest versions 0.0.1 and 0.0.2 contain malicious code that executes at install time via a node-gyp binding.gyp script. This script runs an obfuscated loader that decrypts and decompresses an encrypted payload, then executes it using the Bun runtime. The package masquerades as a benign placeholder but actually delivers a credential stealer payload. The malicious behavior is hidden through multi-layer obfuscation and use of an alternate runtime, making static analysis difficult.
log-sink-testmetest version 1.0.1 is a malicious npm package that executes a concealed credential stealer during installation. It abuses the node-gyp build process by embedding a binding.gyp file that triggers execution of an encrypted payload without any native source code. The payload is heavily obfuscated and decrypts an AES-128-GCM encrypted blob, which is then executed either directly in Node.js or via the Bun runtime to evade detection. The package was published on 2026-10-21 by the npm account 'testnewtestme2'. Version 1.0.0 is clean and unaffected.
The npm package data-pipeline-testmetest version 2.0.1 contains malicious code that executes during installation without a declared install script. It uses a binding.gyp file to run an obfuscated loader that decrypts and executes a large payload. This payload steals credentials from GitHub, npm, PyPI, RubyGems, and cloud services, then commits them to a public GitHub repository created in the victim's account. It also republishes the victim's packages with the same malicious hook. If a GitHub token is found, it installs a destructive service that deletes the user's home directory once the token is revoked. Removal of this service before token revocation and credential rotation is necessary to prevent data loss.
The npm package event-emitter-testmetest contains malicious code in specific versions that use multi-layer obfuscation to execute attacker-controlled payloads. Versions 1.0.6 and 1.0.7 run an obfuscated loader that decrypts and executes code on load or during npm install via a binding.gyp hook. Versions 4.1.0 and 5.0.0 include a stealer payload executed similarly through binding.gyp. Other versions do not contain executable payloads.
## Summary
ApostropheCMS widget styles support project-defined schema fields. If a project defines a free-form `string` style field with a CSS `property` and no selector, an editor-controlled value is rendered as an inline CSS declaration. The resulting declaration is then inserted into the widget wrapper's `style="..."` attribute without HTML-attribute escaping.
An attacker who can edit the widget can include a double quote in the style value, terminate the `style` attribute, and inject new HTML event-handler attributes. The payload is stored with the widget and executes in the Apostrophe site origin whenever the affected published page is rendered.
This is a sibling of CVE-2026-33889 / `GHSA-97v6-998m-fp4g`. The earlier issue escaped from a `<style>` element through a malicious color value. This variant reaches a different sink related to the automatically generated widget wrapper's inline `style` and `class` attributes.
## Details
### Root Cause 1: Free-form string style values retain HTML metacharacters
The standard string field converter uses `launder.string()` and length validation. This performs type normalization, not output encoding for an HTML attribute context:
[`packages/apostrophe/modules/@apostrophecms/schema/lib/addFieldTypes.js:296-333`](https://github.com/apostrophecms/apostrophe/blob/aa5170c7df9ff9ea5ac2e72a008f12e28dae6ca8/packages/apostrophe/modules/%40apostrophecms/schema/lib/addFieldTypes.js#L296-L333)
```javascript
self.addFieldType({
name: 'string',
// ...
convert(req, field, data, destination) {
destination[field.name] = self.apos.launder.string(data[field.name]);
destination[field.name] = checkStringLength(
destination[field.name],
field.min,
field.max
);
}
});
```
Quotes therefore remain in a value supplied through a style field.
### Root Cause 2: The value is converted into inline CSS without value validation
For a field with `property` but no `selector` or media query, `renderScopedStyles()` selects inline rendering. The generic extractor concatenates the configured property and editor-controlled value:
[`packages/apostrophe/modules/@apostrophecms/styles/ui/apos/universal/render.mjs:171-228`](https://github.com/apostrophecms/apostrophe/blob/aa5170c7df9ff9ea5ac2e72a008f12e28dae6ca8/packages/apostrophe/modules/%40apostrophecms/styles/ui/apos/universal/render.mjs#L171-L228)
[`packages/apostrophe/modules/@apostrophecms/styles/ui/apos/universal/render.mjs:598-647`](https://github.com/apostrophecms/apostrophe/blob/aa5170c7df9ff9ea5ac2e72a008f12e28dae6ca8/packages/apostrophe/modules/%40apostrophecms/styles/ui/apos/universal/render.mjs#L598-L647)
```javascript
rule = `${property}: ${normalized.value}${normalized.unit}`;
// ...
if (isInline) {
return {
css: '',
classes: [ ...storage.classes ],
inline: stringifyRules(storage.styles, true)
};
}
```
For example, the value below becomes part of a `font-family` declaration:
```text
serif" tabindex="0" autofocus onfocus="document.body.dataset.inline='executed'
```
### Root Cause 3: Attribute values are serialized without HTML escaping
`getWidgetAttributes()` places the inline CSS into an attribute tuple, then concatenates every tuple into `key="value"` without encoding `&`, `<`, `>`, `'`, or `"`:
[`packages/apostrophe/modules/@apostrophecms/styles/lib/methods.js:251-322`](https://github.com/apostrophecms/apostrophe/blob/aa5170c7df9ff9ea5ac2e72a008f12e28dae6ca8/packages/apostrophe/modules/%40apostrophecms/styles/lib/methods.js#L251-L322)
```javascript
if (styleParts.length) {
attrs.push(
[ 'style', `${styleParts.join(';')};` ]
);
}
if (options.asObject) {
return Object.fromEntries(attrs);
}
return attrs
.map(([ key, value ]) => `${key}="${value}"`)
.join(' ');
```
The same raw serializer also makes a project-defined free-form `string` style with `class: true` a potential sibling path, because the string is added to `classes` and later serialized into `class="..."`. The inline-property path was the path dynamically verified.
### Root Cause 4: The unsafe string is used by the automatic public wrapper
Styled widgets use `getWidgetAttributes()` to create a wrapper around the rendered widget:
[`packages/apostrophe/modules/@apostrophecms/widget-type/index.js:448-457`](https://github.com/apostrophecms/apostrophe/blob/aa5170c7df9ff9ea5ac2e72a008f12e28dae6ca8/packages/apostrophe/modules/%40apostrophecms/widget-type/index.js#L448-L457)
```javascript
if (hasStyles && self.options.stylesWrapper !== false) {
const styles = self.apos.styles.prepareWidgetStyles(widget);
const styleTag = self.apos.styles
.getWidgetElements(styles, { scene: req.scene });
const wrapperAttrs = self.apos.styles.getWidgetAttributes(styles);
return `${styleTag}<div${wrapperAttrs ? ' ' + wrapperAttrs : ''}>${markup}</div>`;
}
```
Consequently, the injected attribute is present on normal public page renders, not only in the editor UI.
### Why the CVE-2026-33889 defense does
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.
The npm package animatecss-tailwind-binary version 2.0.6 is part of a malicious campaign involving fake job interview lures. The package itself contains no install scripts or network code, but it depends on a private scoped package that requires an npm token to access. This private dependency, which was not retrieved during analysis, contains the malicious payload that executes when the Tailwind CSS plugin loads during development server startup. Multiple related malicious packages were published under various accounts over a period from July to October 2026.