Frigate is a network video recorder (NVR) with realtime local object detection for IP cameras. In version 0.17.0, an authenticated non-admin user can retrieve the full raw Frigate configuration through `/api/config/raw`. This exposes sensitive values that are intentionally redacted from `/api/config`, including camera credentials, go2rtc stream credentials, MQTT passwords, proxy secrets, and any other secrets stored in `config.yml`. This appears to be a broken access control issue introduced by the admin-by-default API refactor: `/api/config/raw_paths` is admin-only, but `/api/config/raw` is still accessible to any authenticated user. Version 0.17.1 contains a patch.
CVE-2026-23351 is a use-after-free vulnerability in the Linux kernel's netfilter nft_set_pipapo set type. The flaw arises because commit-time garbage collection (GC) runs for a long time in a non-preemptible context under many expired elements, causing soft lockup warnings and RCU stall reports, leading to local denial of service. The fix involves splitting GC into unlink and reclaim phases to prevent use-after-free conditions during element freeing and pointer swapping.
## Summary
The `object.to_json` builtin function in Scriban performs recursive JSON serialization via an internal `WriteValue()` static local function that has no depth limit, no circular reference detection, and no stack overflow guard. A Scriban template containing a self-referencing object passed to `object.to_json` triggers unbounded recursion, causing a `StackOverflowException` that terminates the hosting .NET process. This is a fatal, unrecoverable crash — `StackOverflowException` cannot be caught by user code in .NET.
## Details
The vulnerable code is the `WriteValue()` static local function at `src/Scriban/Functions/ObjectFunctions.cs:494`:
```csharp
static void WriteValue(TemplateContext context, Utf8JsonWriter writer, object value)
{
var type = value?.GetType() ?? typeof(object);
if (value is null || value is string || value is bool ||
type.IsPrimitiveOrDecimal() || value is IFormattable)
{
JsonSerializer.Serialize(writer, value, type);
}
else if (value is IList || type.IsArray) {
writer.WriteStartArray();
foreach (var x in context.ToList(context.CurrentSpan, value))
{
WriteValue(context, writer, x); // recursive, no depth check
}
writer.WriteEndArray();
}
else {
writer.WriteStartObject();
var accessor = context.GetMemberAccessor(value);
foreach (var member in accessor.GetMembers(context, context.CurrentSpan, value))
{
if (accessor.TryGetValue(context, context.CurrentSpan, value, member, out var memberValue))
{
writer.WritePropertyName(member);
WriteValue(context, writer, memberValue); // recursive, no depth check
}
}
writer.WriteEndObject();
}
}
```
This function has **none** of the safety mechanisms present in other recursive paths:
- `ObjectToString()` at `TemplateContext.Helpers.cs:98` checks `ObjectRecursionLimit` (default 20)
- `EnterRecursive()` at `TemplateContext.cs:957` calls `RuntimeHelpers.EnsureSufficientExecutionStack()`
- `CheckAbort()` at `TemplateContext.cs:464` also calls `EnsureSufficientExecutionStack()`
The `WriteValue()` function bypasses all of these because it is a static local function that only takes the `TemplateContext` for member access — it never calls `EnterRecursive()`, never checks `ObjectRecursionLimit`, and never calls `EnsureSufficientExecutionStack()`.
**Execution flow:**
1. Template creates a ScriptObject: `{{ x = {} }}`
2. Sets a self-reference: `x.self = x` — stores a reference in `ScriptObject.Store` dictionary
3. Pipes to `object.to_json`: `x | object.to_json` → calls `ToJson()` at line 477
4. `ToJson()` calls `WriteValue(context, writer, value)` at line 488
5. `WriteValue` enters the `else` branch (line 515), gets members via accessor, finds "self"
6. `TryGetValue` returns `x` itself, `WriteValue` recurses with the same object — infinite loop
7. `StackOverflowException` is thrown — **fatal, cannot be caught, process terminates**
## PoC
```scriban
{{ x = {}; x.self = x; x | object.to_json }}
```
In a hosting application:
```csharp
using Scriban;
// This will crash the entire process with StackOverflowException
var template = Template.Parse("{{ x = {}; x.self = x; x | object.to_json }}");
var result = template.Render(); // FATAL: process terminates here
```
Even without circular references, deeply nested objects can exhaust the stack since no depth limit is enforced:
```scriban
{{ a = {}
b = {inner: a}
c = {inner: b}
d = {inner: c}
# ... continue nesting ...
result = deepest | object.to_json }}
```
## Impact
- **Process crash DoS**: Any application embedding Scriban for user-provided templates (CMS platforms, email template engines, report generators, static site generators) can be crashed by a single malicious template. The crash is unrecoverable — `StackOverflowException` terminates the .NET process.
- **No try/catch protection possible**: Unlike most exceptions, `StackOverflowException` cannot be caught by application code. The hosting application cannot wrap `template.Render()` in a try/catch to survive this.
- **No authentication required**: `object.to_json` is a default builtin function (registered in `BuiltinFunctions.cs`), available in all Scriban templates unless explicitly removed.
- **Trivial to exploit**: The PoC is a single line of template code.
## Recommended Fix
Add a depth counter parameter to `WriteValue()` and check it against `ObjectRecursionLimit`, consistent with how `ObjectToString` is protected. Also add `EnsureSufficientExecutionStack()` as a safety net:
```csharp
static void WriteValue(TemplateContext context, Utf8JsonWriter writer, object value, int depth = 0)
{
if (context.ObjectRecursionLimit != 0 && depth > context.ObjectRecursionLimit)
{
throw new ScriptRuntimeException(context.CurrentSpan,
$"Exceeding object recursion limit `{context.ObjectRecursion
LoLLMs WEBUI provides the Web user interface for Lord of Large Language and Multi modal Systems. A critical Server-Side Request Forgery (SSRF) vulnerability has been identified in all known existing versions of `lollms-webui`. The `@router.post("/api/proxy")` endpoint allows unauthenticated attackers to force the server into making arbitrary GET requests. This can be exploited to access internal services, scan local networks, or exfiltrate sensitive cloud metadata (e.g., AWS/GCP IAM tokens). As of time of publication, no known patched versions are available.
Frigate is a network video recorder (NVR) with realtime local object detection for IP cameras. Prior to version 0.16.3, the /ffprobe endpoint accepts arbitrary user-controlled URLs without proper validation, allowing Server-Side Request Forgery (SSRF) attacks. An attacker can use the Frigate server to make HTTP requests to internal network resources, cloud metadata services, or perform port scanning. This issue has been patched in version 0.16.3.
CVE-2025-62844 is a medium severity vulnerability in QNAP Systems Inc. QuRouter affecting version 2.6.x. It involves weak authentication that could allow an attacker with local network access to gain sensitive information. The vulnerability has been fixed in QuRouter version 2.6.2.007 and later. There are no known exploits in the wild at this time.
Frigate is a network video recorder (NVR) with realtime local object detection for IP cameras. In versions 0.16.2 and below, users with the viewer role can delete admin and low-privileged user accounts. Exploitation can lead to DoS and affect data integrity. This issue has been patched in version 0.16.3.
Frigate is a network video recorder (NVR) with realtime local object detection for IP cameras. Versions prior to 0.17.0-beta1 allow any authenticated user to change their own password without verifying the current password through the /users/{username}/password endpoint. Changing a password does not invalidate existing JWT tokens, and there is no validation of password strength. If an attacker obtains a valid session token (e.g., via accidentally exposed JWT, stolen cookie, XSS, compromised device, or sniffing over HTTP), they can change the victim’s password and gain permanent control of the account. Since password changes do not invalidate existing JWT tokens, session hijacks persist even after a password reset. Additionally, the lack of password strength validation exposes accounts to brute-force attacks. This issue has been resolved in version 0.17.0-beta1.
Avira Internet Security contains a deserialization of untrusted data vulnerability in the System Speedup component. The Avira.SystemSpeedup.RealTimeOptimizer.exe process, which runs with SYSTEM privileges, deserializes data from a file located in C:\\ProgramData using .NET BinaryFormatter without implementing input validation or deserialization safeguards. Because the file can be created or modified by a local user in default configurations, an attacker can supply a crafted serialized payload that is deserialized by the privileged process, resulting in arbitrary code execution as SYSTEM.
Avira Internet Security contains a time-of-check time-of-use (TOCTOU) vulnerability in the Optimizer component. A privileged service running as SYSTEM identifies directories for cleanup during a scan phase and subsequently deletes them during a separate cleanup phase without revalidating the target path. A local attacker can replace a previously scanned directory with a junction or reparse point before deletion occurs, causing the privileged process to delete an unintended system location. This may result in deletion of protected files or directories and can lead to local privilege escalation, denial of service, or system integrity compromise depending on the affected target.
A use-after-free vulnerability was discovered and fixed in the Linux kernel's netfilter nf_tables subsystem. The flaw occurs in nf_tables_addchain() when error handling fails to properly synchronize RCU grace periods before freeing chain structures, leading to potential use-after-free conditions in both control-plane and packet processing paths. This could allow an attacker with local privileges to cause memory corruption. The issue is addressed by adding synchronize_rcu() calls to ensure safe memory reclamation.
Pi-hole Admin Interface is a web interface for managing Pi-hole, a network-level ad and internet tracker blocking application. Versions 6.4 and below are vulnerable to stored HTML injection through the local DNS records configuration page, which allows an authenticated administrator to inject code that is stored in the Pi-hole configuration and rendered every time the DNS records table is viewed. The populateDataTable() function contains a data variable with the full DNS record value exactly as entered by the user and returned by the API. This value is inserted directly into the data-tag HTML attribute without any escaping or sanitization of special characters. When an attacker supplies a value containing double quotes ("), they can prematurely “close” the data-tag attribute and inject additional HTML attributes into the element. Since Pi-hole implements a Content Security Policy (CSP) that blocks inline JavaScript, the impact is limited. This issue has been fixed in version 6.4.1.
A use-after-free vulnerability in the Linux kernel bonding driver was fixed. The flaw occurs due to a failure during enslaving a new slave device after it has been added to the slave array, allowing use of freed memory. This can lead to kernel crashes and potentially allow an attacker with local privileges to compromise system integrity. The issue is reproducible with specific network interface configurations and traffic. Multiple Linux kernel versions are affected, and patches have been released to address the problem.
A vulnerability in the Linux kernel's netfilter subsystem (nf_tables) involves an inverted check in the nft_map_catchall_activate() function. This flaw causes improper handling of catchall map elements during aborted DELSET operations, leading to a use-after-free condition. The vulnerability allows local privilege escalation via user namespaces and nftables on systems with CONFIG_USER_NS and CONFIG_NF_TABLES enabled. The issue is fixed in Linux kernel versions 6.8.0 and later.
A vulnerability was found in janet-lang janet up to 1.40.1. This affects the function os_strftime of the file src/core/os.c. Performing a manipulation results in out-of-bounds read. The attack must be initiated from a local position. The exploit has been made public and could be used. The patch is named 0f285855f0e34f9183956be5f16e045f54626bff. To fix this issue, it is recommended to deploy a patch.
Frigate is a network video recorder (NVR) with realtime local object detection for IP cameras. Prior to 0.16.4, a critical Remote Command Execution (RCE) vulnerability has been identified in the Frigate integration with go2rtc. The application does not sanitize user input in the video stream configuration (config.yaml), allowing direct injection of system commands via the exec: directive. The go2rtc service executes these commands without restrictions. This vulnerability is only exploitable by an administrator or users who have exposed their Frigate install to the open internet with no authentication which allows anyone full administrative control. This vulnerability is fixed in 0.16.4.
CVE-2026-24071 is a high-severity TOCTOU race condition vulnerability in Native Instruments' Native Access software, affecting versions up to 3.22.0. The vulnerability arises because the privileged helper's XPC service verifies client code signatures based on the client's PID, which is susceptible to PID reuse attacks. An attacker with low privileges can exploit this flaw to impersonate a trusted process, potentially gaining elevated privileges and causing full compromise of confidentiality, integrity, and availability. Exploitation requires local access and high attack complexity but does not require user interaction. No known exploits are currently in the wild. European organizations using Native Access for managing Native Instruments products are at risk, especially those in music production, audio engineering, and related creative industries. Mitigation involves applying vendor patches once available, restricting local access to trusted users, and monitoring for suspicious local IPC activity. Countries with significant creative industries and high adoption of Native Instruments software, such as Germany, the UK, France, and the Netherlands, are most likely to be affected.
Node.js version 25.2.1 contains a vulnerability in its permission model that allows Unix Domain Socket (UDS) connections to bypass network restrictions when the --permission flag is enabled. This flaw permits attacker-controlled inputs to connect to arbitrary local sockets even without the --allow-net permission, breaking the intended security boundary. The issue can lead to unauthorized access to privileged local services, potentially resulting in privilege escalation or data exposure. The network permissions feature was still experimental at the time of this vulnerability.