CVE-2026-0634 is a high-severity vulnerability in the AssistFeedbackService component of TECNO Mobile's TECNO Pova7 Pro 5G running HiOS V15.1.0. It allows local applications with limited privileges to execute arbitrary code with system-level permissions via command injection due to improper neutralization of argument delimiters. This vulnerability can lead to full compromise of confidentiality, integrity, and availability on affected devices. No public exploits are known at this time, and no patch or remediation information is currently available.
CVE-2026-4416 is a high-severity vulnerability in the Performance Library component of the Gigabyte Control Center. It involves insecure deserialization of untrusted data, allowing authenticated local attackers to send malicious serialized payloads to the EasyTune Engine service. Successful exploitation can lead to privilege escalation on the affected system. There is no information about an available patch or vendor advisory at this time. The vulnerability requires local authentication and does not involve user interaction.
In the Linux kernel, the following vulnerability has been resolved: drbd: fix null-pointer dereference on local read error In drbd_request_endio(), READ_COMPLETED_WITH_ERROR is passed to __req_mod() with a NULL peer_device: __req_mod(req, what, NULL, &m); The READ_COMPLETED_WITH_ERROR handler then unconditionally passes this NULL peer_device to drbd_set_out_of_sync(), which dereferences it, causing a null-pointer dereference. Fix this by obtaining the peer_device via first_peer_device(device), matching how drbd_req_destroy() handles the same situation.
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
CVE-2026-33651 is a high-severity SQL injection vulnerability in WWBN AVideo versions up to 26.0. The flaw exists in the remindMe.json.php endpoint where the live_schedule_id parameter is not properly sanitized before being concatenated into a SQL LIKE clause. Although some internal functions apply intval() to local copies, the original tainted input remains unsanitized, enabling authenticated users to perform time-based blind SQL injection attacks. This allows attackers to extract arbitrary database contents, compromising confidentiality and integrity without requiring user interaction. A patch has been committed to address this issue. Organizations using affected versions should prioritize updating to mitigate this risk.
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.
Multiple vulnerabilities were discovered in the Linux kernel, including issues in the AppArmor Linux Security Module that could allow unprivileged local attackers to manipulate AppArmor profiles, potentially causing denial of service, information disclosure, local privilege escalation, or container escape. Additionally, some AMD Zen 5 processors with RDSEED instruction had entropy handling flaws that could lead to compromised randomness, affecting confidentiality and integrity. Numerous other kernel subsystems and drivers were also affected by various security flaws.
CVE-2026-31957 is a critical vulnerability in himmelblau versions 3.0.0 up to but not including 3.1.0, an interoperability suite for Microsoft Azure Entra ID and Intune. The issue arises when himmelblau is deployed without a configured tenant domain in its configuration file, causing authentication to be unscoped to any tenant. This allows the system to accept authentication attempts for arbitrary Entra ID domains by dynamically registering providers at runtime, which is intended only for initial or local bootstrap scenarios. In remote authentication environments, this behavior can lead to unauthorized access, compromising confidentiality, integrity, and availability. The vulnerability has a CVSS score of 10.0, indicating critical severity, and is fixed in version 3.
Time-of-check time-of-use race condition in the UEFI PdaSmm module for some Intel(R) reference platforms may allow an information disclosure. System software adversary with a privileged user combined with a high complexity attack may enable data exposure. This result may potentially occur via local access when attack requirements are not present without special internal knowledge and requires no user interaction. The potential vulnerability may impact the confidentiality (high), integrity (none) and availability (none) of the vulnerable system, resulting in subsequent system confidentiality (none), integrity (none) and availability (none) impacts.
Time-of-check time-of-use race condition in the WheaERST SMM module for some Intel(R) reference platforms may allow an escalation of privilege. System software adversary with a privileged user combined with a high complexity attack may enable escalation of privilege. This result may potentially occur via local access when attack requirements are present without special internal knowledge and requires no user interaction. The potential vulnerability may impact the confidentiality (high), integrity (high) and availability (high) of the vulnerable system, resulting in subsequent system confidentiality (none), integrity (none) and availability (none) impacts.
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 vulnerability was determined in YosysHQ yosys up to 0.62. This affects the function Yosys::RTLIL::Const::set of the file kernel/rtlil.h of the component BLIF File Parser. This manipulation causes heap-based buffer overflow. It is possible to launch the attack on the local host. The exploit has been publicly disclosed and may be utilized. Applying a patch is the recommended action to fix this issue. It appears that the issue is not reproducible all the time.
CVE-2024-28397 is a medium severity vulnerability in the js2py library up to version 0.74. It involves the js2py.disable_pyimport() component, which allows attackers with local privileges to execute arbitrary code via a crafted API call. The vulnerability has a CVSS 3.1 base score of 5.3, indicating a moderate risk. No official patch or remediation details are provided in the available data. There are no known exploits in the wild at this time.
A coordinated campaign is targeting developers through malicious repositories disguised as legitimate Next.js projects and technical assessment materials. The attack uses multiple entry points that lead to runtime retrieval and local execution of attacker-controlled JavaScript, transitioning into staged command-and-control. The campaign employs three main execution paths: Visual Studio Code workspace automation, build-time execution during application development, and server startup execution via environment variable exfiltration and dynamic remote code execution. The attack chain includes a Stage 1 C2 beacon for registration and a Stage 2 C2 controller for persistent tasking. This sophisticated approach allows attackers to blend into routine developer workflows, increasing the likelihood of code execution and potentially compromising high-value assets such as source code, environment secrets, and access to build or cloud resources.
eBay API MCP Server is an open source local MCP server providing AI assistants with comprehensive access to eBay's Sell APIs. All versions are vulnerable to Environment Variable Injection through the updateEnvFile function. The ebay_set_user_tokens tool allows updating the .env file with new tokens. The updateEnvFile function in src/auth/oauth.ts blindly appends or replaces values without validating them for newlines or quotes. This allows an attacker to inject arbitrary environment variables into the configuration file. An attacker can inject arbitrary environment variables into the .env file. This could lead to configuration overwrites, Denial of Service, and potential RCE. There was no fix for this issue at the time of publication.
Improper Control of Filename for Include/Require Statement in PHP Program ('PHP Remote File Inclusion') vulnerability in villatheme Sales Countdown Timer for WooCommerce and WordPress sctv-sales-countdown-timer allows PHP Local File Inclusion.This issue affects Sales Countdown Timer for WooCommerce and WordPress: from n/a through < 1.1.9.
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.