CVE-2026-68522 is a vulnerability in codidact qpixel prior to version 0.13.0 where unauthenticated users can access comment data without proper authorization. The comments#show action uses Comment.unscoped, bypassing community scoping and authorization checks, allowing attackers to enumerate comment IDs and read sensitive comment content, including soft-deleted and access-restricted comments. The issue is fixed in version 0.13.0.
In FRRouting, bgpd frees the sub-TLV chain of a Tunnel Encapsulation attribute (type 23) while routes stored by bgpd still point to it, if the attribute is received from a neighbor that has "soft-reconfiguration inbound" configured. A cache added to speed up attribute interning while processing the prefixes of an UPDATE checks whether an interned attribute set may be reused by comparing the parsed attributes with themselves, so the check always succeeds. Interning the parsed attributes for the Adj-RIB-In removes the Tunnel Encapsulation sub-TLVs from them, and the copy that bgpd then interns for the route reuses the cached attribute set, which still holds the sub-TLVs, without taking a reference on them. When the route is later replaced, withdrawn or cleared, for example when the session goes down, the sub-TLV chain is freed while still in use, and bgpd then reads it, decrements a reference count inside it and frees it a second time. In the reporter's build without AddressSanitizer this ended in an assertion failure in bgpd's memory accounting, aborting bgpd and dropping all BGP sessions on the router, and the neighbor can repeat it each time bgpd restarts. Because freed heap memory is written to and freed again, consequences beyond a crash cannot be ruled out. An established BGP session is required, and the attribute does not need to be malformed. bgpd processes attribute 23 from every neighbor, including eBGP neighbors, unless it is explicitly discarded, although RFC 9012 requires it to be filtered on eBGP sessions by default. Neighbors without "soft-reconfiguration inbound" are not affected.
A vulnerability in filelock versions 3.22.0 through 4.2.0 allows a local unprivileged user to cause two processes of the lock owner to simultaneously hold the same soft file lock. This occurs due to a stale-lock break mechanism that incorrectly removes a live lock file when inode numbers are reused by the filesystem (e.g., ext4, xfs). The flaw requires a sticky shared directory where the attacker can create files and a race condition between lock contenders. The integrity of the lock is compromised, allowing concurrent holders to write protected data without detection.
CVE-2026-105420 is a critical path traversal vulnerability in Wing Soft Technology's Wing FTP Server. The server fails to verify a user's base folder, allowing an attacker with admin privileges to add user directories via scripts that escape the intended base folder. This enables the attacker to write arbitrary files on the system, potentially leading to remote code execution with the privileges of the process owner. Since the installation guide recommends running the server with sudo, the files may be created with root privileges. The vulnerability is fixed in version 8.2.6.
CVE-2026-98489 is a vulnerability in the Linux kernel's atl1c network driver that causes a soft lockup due to an out-of-range tpd_cons read. The hardware can report a tpd_cons value of 0xffff during PCIe link or MAC reset, which the driver loop interprets incorrectly and spins indefinitely. This issue has been reproduced on systems with Qualcomm Atheros AR8151 v2.0 NICs, triggered by rebooting a Mikrotik CCR2004 PCIe card. The problem leads to a CPU soft lockup detected by the watchdog, causing system instability.
CVE-2026-85215 is a high-severity SQL injection vulnerability in GG Soft Software Services Inc.'s Paperwork product affecting versions up to 2026-09-09. The flaw involves improper neutralization of special elements in SQL commands, potentially allowing unauthorized data access or manipulation. No known exploits are reported in the wild, and no patch information is provided.
A vulnerability in Apache Tomcat affects CLIENT_CERT authentication where it does not fail as expected in some scenarios when soft fail is disabled. This issue impacts Apache Tomcat versions 9.0.92 through 9.0.121, 10.1.22 through 10.1.59, and 11.0.0 through 11.0.25. Fixed versions are 9.0.122, 10.1.60, and 11.0.26. Users are advised to upgrade to these fixed versions to resolve the issue.
A vulnerability in the Linux kernel's fq_pie network scheduler allows users with CAP_NET_ADMIN capability to cause a denial of service via a crafted quantum value. Specifically, the fq_pie_change() function accepts any quantum value from userspace, including 1, which can cause a soft lockup due to a long spinning loop under the qdisc lock. This issue affects certain versions of the linux-hwe-edge kernel and requires specific configuration and commands to trigger.
A vulnerability in the Linux kernel's jbd2 component allows excessive scanning of checkpoint buffers while holding a lock, potentially causing soft lockups or RCU stalls. The issue arises because busy buffers do not reduce the scan budget, leading to prolonged lock hold times when checkpoint transactions contain many busy buffers. This vulnerability has been resolved by adjusting the scan budget accounting to include busy buffers during scanning, restoring previous scan-budget semantics.
snipe-it versions before 8.7.0 fail to enforce asset view authorization in the GET /hardware/{asset}/barcode endpoint. Authenticated attackers can iterate asset IDs to retrieve barcodes and enumerate asset tags across tenants, including soft-deleted and cross-company assets.
Snipe-IT is an IT asset/license management system. Prior to 8.6.3, a company-scoped user in FMCS floater mode can access users whose company_id is null because broad API queries and bulk web actions do not consistently apply isCurrentUserHasAccess. The /api/v1/users and /api/v1/users/{id}/licenses endpoints can expose personal data and assigned licenses, /users/bulkeditsave can modify out-of-scope profiles, and /users/merge can soft-delete users and transfer assigned assets. This issue is fixed in version 8.6.3.
CVE-2026-74411 is a vulnerability in the Linux kernel's rtw89 Wi-Fi driver where an incorrect data type for the scan index caused an infinite loop during Wi-Fi scanning on the 6GHz band. This results in a kernel soft lockup, causing the CPU to become stuck for over 20 seconds and potentially leading to a system panic. The issue occurs in the function rtw89_hw_scan_add_chan_ax due to the scan index counter overflowing and not terminating the loop properly. The vulnerability has been fixed in multiple Linux kernel versions.
A vulnerability in the Linux kernel's posix-cpu-timers subsystem causes incorrect CPU timer expiry programming on 32-bit kernels. The issue arises from a 32-bit multiplication overflow when converting RLIMIT_CPU values to nanoseconds in update_rlimit_cpu(), leading to premature timer firing for soft limits of 5 seconds or more. This affects only 32-bit kernels; 64-bit kernels are not impacted. The enforcement of CPU time limits remains correct, but the timer expiry cache is set incorrectly. The flaw is fixed in specific Linux kernel commits.
In the Linux kernel, the following vulnerability has been resolved:
xfrm: iptfs: fix ABBA deadlock in iptfs_destroy_state()
iptfs_destroy_state() calls hrtimer_cancel() while holding a spinlock
that the timer callback also acquires, leading to an ABBA deadlock on
SMP systems.
For the output timer (iptfs_timer):
- iptfs_destroy_state() holds x->lock, calls hrtimer_cancel()
- iptfs_delay_timer() callback takes x->lock
For the drop timer (drop_timer):
- iptfs_destroy_state() holds drop_lock, calls hrtimer_cancel()
- iptfs_drop_timer() callback takes drop_lock
Both timers use HRTIMER_MODE_REL_SOFT, so their callbacks run in softirq
context. When hrtimer_cancel() is called for a soft timer that is
currently executing on another CPU, hrtimer_cancel_wait_running() spins
on softirq_expiry_lock -- the same lock held by the softirq running the
callback. If the callback is blocked waiting for the spinlock held by
the caller of hrtimer_cancel(), a circular dependency forms:
CPU 0: holds lock_A -> waits for softirq_expiry_lock
CPU 1: holds softirq_expiry_lock -> waits for lock_A
Fix by calling hrtimer_cancel() before acquiring the respective locks.
hrtimer_cancel() is safe to call without holding any lock and will wait
for any in-progress callback to complete. For the output timer, the
lock is still acquired afterwards to drain the packet queue. For the
drop timer, the lock/unlock pair is removed entirely since it only
existed to serialize with the timer callback, which hrtimer_cancel()
already guarantees.
Found by source code audit.
Tomcat is the servlet container that is used in the official Reference Implementation for the Java Servlet and JavaServer Pages technologies. The Java Servlet and JavaServer Pages specifications are developed by Sun under the Java Community Process. Tomcat is developed in an open and participatory environment and released under the Apache Software License version 2.0. Tomcat is intended to be a collaboration of the best-of-breed developers from around the world.
Security Fix(es):
* tomcat: Apache Tomcat: Certificate revocation bypass due to improper OCSP response validation (CVE-2026-24734)
* tomcat: Client certificate verification bypass due to virtual host mapping (CVE-2025-66614)
* tomcat: security constraint bypass with HTTP/0.9 (CVE-2026-24733)
* Apache Tomcat: Apache Tomcat: Authentication bypass due to CLIENT_CERT soft fail misconfiguration (CVE-2026-29145)
* Apache Tomcat: Apache Tomcat: Information disclosure via sensitive data in log files (CVE-2026-34487)
* Apache Tomcat: Apache Tomcat: Open Redirect vulnerability via LoadBalancerDrainingValve (CVE-2026-25854)
* Apache Tomcat: Apache Tomcat: HTTP Request/Response Smuggling via invalid chunk extension (CVE-2026-24880)
* Apache Tomcat: Apache Tomcat: Authentication bypass via client certificate misconfiguration (CVE-2026-34500)
* Apache Tomcat: Apache Tomcat: Information disclosure due to improper encoding in JsonAccessLogValve (CVE-2026-34483)
For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.
`src/main/java/org/springframework/data/mapping/context/PersistentPropertyPathFactory.java:175` · Unbounded Resource Allocation (Algorithmic DoS)
### Impact
When a consuming module routes user-supplied dot-paths (sort parameters, projection paths, PATCH paths) through `MappingContext.getPersistentPropertyPath(String, Class)`, each distinct string — including invalid ones — is cached forever. A remote attacker can send millions of requests with unique `?sort=aaaa<n>` values and grow the heap until the service OOMs.
### Description
`PersistentPropertyPathFactory.propertyPaths` (line 53) is a `ConcurrentHashMap<TypeAndPath, PathResolution>` populated by `getPotentiallyCachedPath()` (line 174-177) via `computeIfAbsent`. The key is `(TypeInformation, rawPathString)`. Crucially, unresolvable paths are also cached (as `PathResolution.unresolved`, line 204) so that the same `InvalidPersistentPropertyPath` can be re-thrown — meaning every distinct garbage string an attacker sends creates a permanent entry. There is no eviction. This is reachable from `AbstractMappingContext.getPersistentPropertyPath(String, Class)` (`AbstractMappingContext.java:345`), which Spring Data REST and several store query mappers call with HTTP-request-derived sort/filter property names.
By contrast, the sibling `SimplePropertyPath.cache` was already hardened to use `ConcurrentReferenceHashMap` (soft refs); this cache was not given the same treatment.
### Exploit scenario
Against a Spring Data REST endpoint, an attacker scripts `GET /things?sort=<random-40-char-string>` in a loop. Each request fails fast with `InvalidPersistentPropertyPath`, but each distinct random string leaves behind a `TypeAndPath` key, a `PathResolution` object holding the split segments list, and the source string in the map. After ~10M requests the JVM OOMs.
### Preconditions
- A downstream component (Spring Data REST, a store-specific `QueryMapper`, or application code) passes externally-supplied strings to `MappingContext.getPersistentPropertyPath(String, ...)`
- No upstream rate-limiting or path-string validation
### How to fix
A cache whose key can be derived from external input must be bounded. Replace `propertyPaths` (line 53) with a `ConcurrentLruCache<TypeAndPath, PathResolution>` of fixed capacity, or `ConcurrentReferenceHashMap` (matching the sibling `SimplePropertyPath.cache`). Additionally, do not cache `PathResolution.unresolved` results at all (line 204 in `createPersistentPropertyPath`) — re-computing a failed lookup is cheap, and caching negative results for arbitrary attacker strings is what makes this exploitable.
### Adversarial verification
**Verdict:** TRUE_POSITIVE (confidence: 7/10) — unbounded hard-ref `ConcurrentHashMap` keyed by raw path string, caches unresolved entries (line 204), reachable via public `MappingContext.getPersistentPropertyPath(String, ...)`; sibling `PropertyPath` cache was already converted to soft-refs but this one was missed. -3 confidence because the HTTP-input wiring lives in downstream modules (Spring Data REST / store mappers), not verifiable in this repo.
**Code at the line — CONFIRMED**
- Line 53: `private final Map<TypeAndPath, PathResolution> propertyPaths = new ConcurrentHashMap<>();` — plain CHM, hard refs, no eviction, no size bound.
- Line 175: `propertyPaths.computeIfAbsent(TypeAndPath.of(type, propertyPath), ...)` — every distinct `(type, string)` pair is inserted.
- Line 204: `return PathResolution.unresolved(parts, segment, type, currentPath);` — returned from inside `computeIfAbsent`'s mapping function, so unresolvable paths are cached. The `PathResolution` retains the full attacker string (`source = StringUtils.collectionToDelimitedString(parts, ".")`, line 452).
**Callers within spring-data-commons**
- `AbstractMappingContext.getPersistentPropertyPath(String, Class<?>)` (line 345) and `(String, TypeInformation<?>)` (line 350) → `persistentPropertyPathFactory.from(type, propertyPath)` → straight into the unbounded cache. No validation, no `PropertyPath.from` gate.
- This is the public `MappingContext` interface (`MappingContext.java:174,186`), documented to throw `InvalidPersistentPropertyPath` on bad input — i.e., the contract explicitly anticipates being called with possibly-invalid strings.
- No in-repo caller routes HTTP input directly into the `String` overload. The `Sort.Order.property` → `getPersistentPropertyPath(String, ...)` bridge lives in store modules (Spring Data MongoDB `QueryMapper`, Spring Data REST sort translator). That wiring is out-of-repo as the finding states.
**Protections — NONE on this cache**
Contrast: `SimplePropertyPath.java:52` (the `PropertyPath.from` cache) uses `ConcurrentReferenceHashMap` (soft refs, GC-evictable). Spring already hardened the sibling cache against exactly this pattern. `PersistentPropertyPathFactory.propertyPaths` was not given the same treatment.
**Stress-test**
Is this exclusion #3 (intended design)? The `PathResolution` javadoc (line
Red Hat JBoss Web Server is a fully integrated and certified set of components for hosting Java web applications. It is comprised of the Apache Tomcat Servlet container, JBoss HTTP Connector (mod_cluster), the PicketLink Vault extension for Apache Tomcat, and the Tomcat Native library.
This release of Red Hat JBoss Web Server 6.2.3 serves as a replacement for Red Hat JBoss Web Server 6.2.2. This release includes bug fixes, enhancements and component upgrades, which are documented in the Release Notes that are linked to in the References section.
Security Fix(es):
* tomcat: Apache Tomcat: HTTP Request/Response Smuggling via invalid chunk extension (CVE-2026-24880)
* tomcat: Apache Tomcat: Open Redirect vulnerability via LoadBalancerDrainingValve (CVE-2026-25854)
* tomcat: Apache Tomcat: Authentication bypass due to CLIENT_CERT soft fail misconfiguration (CVE-2026-29145)
* tomcat: Apache Tomcat: Information disclosure via Padding Oracle vulnerability in EncryptInterceptor (CVE-2026-29146)
* tomcat: Apache Tomcat: Information disclosure due to improper encoding in JsonAccessLogValve (CVE-2026-34483)
* tomcat: Apache Tomcat: Information disclosure via sensitive data in log files (CVE-2026-34487)
* tomcat: Apache Tomcat: Authentication bypass via client certificate misconfiguration (CVE-2026-34500)
For more details about the security issue(s), including the impact, a CVSS score, acknowledgments, and other related information, refer to the CVE page(s) listed in the References section.
CVE-2026-46051 is a vulnerability related to a soft lockup issue in the md/raid5 component's retry_aligned_read() function. The information provided is limited and does not include technical details about the nature of the vulnerability or its exploitation. There is no CVSS score available, and no known exploits in the wild have been reported. The affected products include Microsoft and Azure Linux 3.0 versions. No patch or remediation details are provided in the available data.