A use-after-free vulnerability exists in the Linux kernel's openvswitch component related to connection tracking (CT) limit teardown. This flaw allows an unprivileged user with access to user and network namespaces to trigger a slab-use-after-free condition during network namespace teardown, potentially leading to high impact including confidentiality, integrity, and availability loss. The issue arises because the CT limit pointer was not properly synchronized with RCU readers during teardown. The vulnerability has been fixed by publishing the CT limit pointer through RCU, removing it before teardown, and waiting for readers before freeing its contents, with proper locking mechanisms in place.
Siyuan before v3.8.2 contains an information disclosure vulnerability in the POST /api/search/fullTextSearchBlock endpoint that filters private blocks from results but returns unfiltered match counts. Unauthenticated publish-mode readers can submit arbitrary search terms to learn whether matching content exists in hidden or unpublished documents and determine the number of matching blocks and pages.
CVE-2026-72923 is an uncontrolled resource consumption vulnerability in Microsoft OpenAPI.NET's YAML parsing components. It arises from nested anchors and aliases in YAML OpenAPI documents, which can cause exponential memory allocation during conversion to JSON nodes. This can lead to process termination due to out-of-memory conditions. The vulnerability affects Microsoft.OpenApi.YamlReader versions >=2.0.0-preview.11 and <2.12.0, >=3.0.0 and <3.10.0, and Microsoft.OpenApi.Readers versions <1.6.30. Patched versions are available that impose limits on node count and nesting depth to prevent unbounded expansion. The impact is limited to availability and denial of service; no code execution or data exposure is reported.
SiYuan versions before v3.8.2 fail to properly filter private attribute-view cell values in the getAttributeViewKeys endpoint. Publish readers can retrieve hidden KeyValues payloads from rows bound to inaccessible documents, exposing private database contents without authorization.
In the Linux kernel, the following vulnerability has been resolved: mshv: Order pt_vp_array publish against irqfd assertion path mshv_partition_ioctl_create_vp() initialises a VP struct (allocations, mutex_init, init_waitqueue_head, page mappings) and then publishes the pointer into partition->pt_vp_array. Several ISR paths read this array locklessly: the intercept ISR, the two scheduler ISRs, and mshv_try_assert_irq_fast() on the irqfd fast path. Of these, only mshv_try_assert_irq_fast() can structurally race the publish. It runs from an eventfd waker without holding pt_mutex, and MSHV_IRQFD does not require the target lapic_apic_id (== vp_index) to refer to an existing VP at registration time. A user can therefore register an irqfd targeting a yet-to-be-created VP, then trigger mshv_try_assert_irq_fast() concurrently with MSHV_CREATE_VP for the same index. On weakly-ordered architectures the reader can observe a non-NULL pointer in pt_vp_array before the initialising stores to the VP struct become visible, leading to use of partially-initialised fields (e.g. vp_register_page). The other ISR readers cannot reach this race: the hypervisor will not generate intercept or scheduler messages for a VP that has never been told to run, and the user can only call MSHV_RUN_VP on the VP fd returned by MSHV_CREATE_VP, which by construction is returned after the publish. Leave those readers as plain loads. Use smp_store_release() in mshv_partition_ioctl_create_vp() to publish the pointer, and pair it with smp_load_acquire() in mshv_try_assert_irq_fast(). On x86 these compile to plain accesses under TSO; on ARM64 they emit one-instruction acquire/release barriers, acceptable on this fast path. The destroy-side path (destroy_partition() clearing pt_vp_array[i] to NULL after kfree(vp)) has a separate ordering and lifetime concern that is out of scope here.
A concurrency issue was identified in the Linux kernel's FUSE io-uring queue initialization where the queue pointer was published without proper memory ordering guarantees. This could lead to readers accessing incompletely initialized queue data due to insufficient synchronization primitives. The flaw was addressed by changing the pointer publication to use smp_store_release() and ensuring readers use READ_ONCE() to avoid undefined behavior in concurrent access scenarios.
A vulnerability in the Linux kernel fbdev subsystem involves unsynchronized access to fb_info->modelist and fb_info->mode, which can lead to use-after-free conditions. The issue arises because show_mode(), show_modes(), and store_mode() functions access these structures without holding the required lock_fb_info() lock, while store_modes() replaces and frees the modelist under lock. This can cause concurrent readers or writers to dereference freed memory or use stale pointers. The fix involves serializing access with lock_fb_info() in the affected functions and carefully managing locking during mode activation and assignment.
In the Linux kernel, the following vulnerability has been resolved: ALSA: usb-audio: Complete cleanup after system-resume errors A failed system resume can leave the card unusable until reboot. usb_audio_resume() jumps to err_out when snd_usb_pcm_resume() or snd_usb_mixer_resume() fails. The error path skips the out: block, which restores D0 and decrements chip->num_suspended_intf. The card stays in SNDRV_CTL_POWER_D3hot, so later control access blocks in snd_power_ref_and_wait(). USB core logs an interface resume callback error. It does not retry that callback, so a later callback cannot complete the skipped cleanup. usb_audio_suspend() increments num_suspended_intf before returning success. A system-resume callback must consume the system-suspend count even if a component resume fails. Otherwise, the stranded count skews later suspend and resume cycles. Do not apply this cleanup to runtime-resume errors. Runtime PM can retry -EAGAIN or -EBUSY without another suspend callback. The count must continue to describe that suspended interface. Other runtime-resume errors latch runtime_error in the PM core and do not cause an immediate callback retry. Both parts of the system-resume error path are longstanding. Commit 88a8516a2128a ("ALSA: usbaudio: implement USB autosuspend") introduced err_out past the D0 restore. Commit 862b2509d157c ("ALSA: usb-audio: Fix inconsistent card PM state after resume") later moved num_suspended_intf-- into the out: block. The error path now skips both operations. No third-party code is needed to reach the error path. snd_usb_mixer_resume() ends in snd_usb_mixer_activate(), which returns the result of usb_submit_urb() for devices that have a mixer status URB. Its mixer->private_resume hook can also fail through scarlett2_init_notify(). snd_usb_pcm_resume() issues a SET_CUR request to a UAC3 power domain. It can return -EPIPE or -EIO when the device stalls the request. Route a component error through out: only when system_suspend is nonzero. Continue to return runtime-resume errors through err_out. Later component resume stages remain skipped. The original error still reaches USB core. A later transfer can fail if the device did not recover. I reproduced the system-resume failure on an Audient iD14 MkI with an out-of-tree diagnostic mixer resume hook. An injected -EIO on the unpatched core left control readers in uninterruptible sleep in snd_power_ref_and_wait() until a reboot. With this patch, the same failure restored control access. A second system suspend and resume also succeeded after I disabled fault injection.
A quadratic CPU exhaustion vulnerability exists in NLTK's XMLCorpusView._read_xml_fragment() function. The function accumulates XML data in 1 KiB blocks and rescans the entire accumulated buffer on each iteration, causing CPU time to grow quadratically with input size. This can lead to denial of service when processing attacker-controlled malformed XML corpus files. The issue affects multiple corpus readers relying on XMLCorpusView but not XMLCorpusReader.xml(). Verified in NLTK versions 3.9.4, 3.10.0, and current development branches. A fix is available in version 3.8.1_2.
NLTK corpus readers ipipan, crubadan, and lin improperly handle symlinks inside trusted corpus roots, allowing path traversal outside the intended root. This occurs because these readers reopen root-derived paths using Python's raw open() instead of NLTK's pathsec.open(), bypassing pathsec's symlink enforcement. An attacker able to place symlinks inside a trusted corpus root can cause the readers to disclose content from outside the root through normal corpus-reader methods. This vulnerability affects versions from 3.3.1 up to but not including 3.8.1_2 and is patched in 3.8.1_2. The CVSS 4.0 score is 8.2 (high severity).
NLTK versions prior to 3.8.1_2 have a sandbox bypass vulnerability in the corpus reader constructors. The vulnerability allows corpus readers such as LinThesaurusCorpusReader and PanLexLiteCorpusReader to perform file and database reads outside the intended sandbox root, bypassing the pathsec sandbox enforcement. This occurs because the CorpusReader.__init__ method converts the root path into a FileSystemPathPointer without applying pathsec validation, allowing unsafe access via builtin open() and sqlite3.connect(). A proof-of-concept demonstrates that pathsec.open blocks direct unsafe reads, but these corpus readers still succeed in accessing outside paths. This vulnerability requires no special privileges beyond supplying a corpus root path.
NLTK version 3.9.4 contains a path traversal vulnerability in its FrameNet and NKJP corpus readers. This flaw allows parsing of XML files outside the trusted corpus root by using unsafe selectors or poisoned index state. The issue is fixed in version 3.10.0, which enforces path-safety checks to prevent outside-root XML parsing.