CVE-2026-92942 is a high-severity vulnerability in the patriksimek vm2 library versions prior to 3.11.7. The vulnerability arises because the VM timeout option does not apply to code executed outside the synchronous VM#run() call, allowing sandboxed code to register FinalizationRegistry cleanup callbacks that can execute unbounded busy loops after the VM run returns. This can block the host event loop indefinitely, causing a denial of service. The invocation timing depends on the V8 garbage collector behavior.
vm2 3.11.3 through 3.11.6 exposes the host Node.js crypto module to a NodeVM sandbox when the crypto builtin is allowed. The module is presented via a recursive read-only proxy, but its callable exports still execute with host-process authority. Sandboxed JavaScript can therefore call crypto.setEngine() with a filesystem path to an attacker-supplied native library (for example, one bundled in an untrusted plugin package already written to disk); OpenSSL asks the operating-system dynamic loader to load the file, and the library's constructor executes native code in the host process before engine-symbol validation rejects it. Exploitation requires only the crypto builtin and does not require fs, process, module, child_process, worker_threads, vm, or inspector access, resulting in a sandbox escape and arbitrary native code execution. Fixed in 3.11.7.
vm2 versions 3.11.3 through 3.11.6 expose Node.js's host node:sqlite module to code running in NodeVM when that builtin is permitted, either explicitly or through builtin: ['*']. The module is wrapped with vm.readonly(), which prevents property assignment but leaves host-authority callables reachable; in addition, the resolver treats any request starting with 'node:' as a core-module request and the runtime strips only one 'node:' prefix, so a sandbox request for 'node:node:sqlite' resolves to the configured node:sqlite entry. Sandboxed code can therefore create an in-memory DatabaseSync with extension loading enabled and call DatabaseSync.loadExtension() on a native library bundled in the untrusted plugin package (path derived from __dirname). SQLite loads the library into the Node.js host process and invokes its native entry point, giving the sandboxed plugin arbitrary native code execution outside the sandbox with the host process's privileges. The issue is fixed in vm2 3.11.7.
vm2 version 3.11.6 contains a critical sandbox escape vulnerability that allows untrusted code to execute arbitrary commands on the host Node.js process. The vulnerability arises from improper sanitization of rejected host Promise values when rejection handlers are registered via Function.prototype.call or .apply indirection. This flaw enables sandboxed code to obtain a proxy to host objects, leading to remote code execution. The issue is fixed in vm2 version 3.11.7.
vm2 is a sandbox for running untrusted Node.js code. In versions <= 3.11.7, NodeVM exposes the host `util` module to the sandbox as an unfiltered shallow copy (`Object.assign({}, util)` in `defaultBuiltinLoaderUtil`), and the deprecated `sys` builtin (an alias of host `util`) is exposed through the generic builtin loader. On Node.js >= 22.9 this hands sandboxed code `util.getCallSites()`, a programmatic stack-introspection API that returns the host process's full call stack, including absolute file paths, function names, and line numbers for vm2 bridge internals and the embedding application's entrypoint. This bypasses the host-frame redaction introduced for GHSA-v27g-jcqj-v8rw, which only applies to the `Error.prepareStackTrace` formatting channel. The issue is fixed in vm2 3.11.8.
google-protobuf contains an unbounded recursion when parsing unknown protobuf group fields. An attacker can send a small crafted payload of deeply nested START_GROUP wire bytes to any Node.js service that calls the generated deserializeBinary() API, causing a RangeError: Maximum call stack size exceeded and crashing the process. No authentication or prior knowledge of the schema is required.
WWBN AVideo through commit e01e41ecc (no patched version available) contains a broken access control flaw in objects/userVerifyEmail.php. The script disables the login requirement ($global['ignoreUserMustBeLoggedIn'] = 1), takes users_id directly from the query string, and calls User::sendVerificationLink() with no session requirement, no CSRF/global token, no relationship check between caller and target, and no enforceRateLimit() call. The only intended throttle is keyed to the caller's own session, so cookie-less requests are never limited. An unauthenticated remote attacker can therefore cause an arbitrary number of verification emails to be sent to any account ID, and can enumerate accounts and their verification status from the three distinct JSON responses ("Verification Sent", "Already verified", "Unknown error"). In addition, createVerificationCode() invokes $user->setRecoverPass() and saves the user, so each anonymous request writes a live password-recovery token onto the targeted account; that token is embedded in base64 in the verification link emailed to the account owner and is accepted by objects/userRecoverPassSave.json.php as the credential for setting a new password.
RMCP is an official Rust SDK for the Model Context Protocol. Prior to 2.0.0, the rmcp crate's stateful Streamable HTTP server in crates/rmcp/src/transport/streamable_http_server/tower.rs allows an unauthenticated client to send a well-formed JSON-RPC POST that is not an initialization request, or an initialization request with a mismatched protocol header, causing StreamableHttpService::handle_post to call LocalSessionManager.create_session before validating the message. An early validation failure returns without removing the inserted LocalSessionHandle from LocalSessionManager.sessions, permanently retaining session and channel state for the server process lifetime. Repeated requests can grow the shared session table without bound, degrade legitimate-client latency through lock contention, exhaust memory, and terminate the server. This issue is fixed in version 2.0.0.
CVE-2026-89799 is a high-severity vulnerability in the Linux kernel related to the bpf subsystem. It involves improper handling of preemption in the bpf_get_stackid function, which has been resolved by disabling preemption during critical operations accessing the trace entries buffer. This fix ensures stability and security when retrieving performance call chains.
A vulnerability in the Linux kernel's iio light sensor driver for apds9306 caused a power management (PM) reference leak in the apds9306_read_data() function. The function calls pm_runtime_resume_and_get() but on several error paths fails to call pm_runtime_put_autosuspend(), which leaks the runtime PM reference and prevents the device from autosuspending. This issue has been resolved by using PM_RUNTIME_ACQUIRE_AUTOSUSPEND() and PM_RUNTIME_ACQUIRE_ERR() to ensure proper runtime PM reference release on all return paths.
A use-after-free vulnerability was resolved in the Linux kernel's iio chemical atlas-sensor driver. The issue involved improper handling of IRQ work after device removal, which could lead to dereferencing freed memory. The fix replaces irq_work queuing with a direct call to iio_trigger_poll_nested() to ensure proper synchronization and resource cleanup.
A vulnerability in the Linux kernel's iio chemical atlas-sensor driver caused a power management (PM) reference leak in the buffer postenable function. The function atlas_buffer_postenable() acquires a runtime PM reference but may leak it if atlas_set_interrupt() fails, preventing the device from autosuspending properly. This issue has been resolved by adding a call to pm_runtime_put_autosuspend() on the error path to balance the PM reference.
A vulnerability in the Linux kernel's amdxdna driver allows a zero-length flush SYNC_BO request to cause a kernel page fault. This occurs because the flush operation does not properly constrain the size, leading to an access in a guard page below the vmalloc area and resulting in a kernel oops. Any process with access to the render node can trigger this fault by issuing a SYNC_BO call with size zero on an AMDXDNA_BO_SHARE object. This issue has been reproduced reliably on specific hardware.
A vulnerability in the Linux kernel's IMA subsystem was resolved where the function validate_hash_algo() did not properly check for error pointers returned by dentry_path(). This caused the integrity_audit_message() function to call strlen() on an invalid pointer, leading to a kernel crash (page fault). The fix involves checking for error pointers and using NULL instead to prevent the crash.
A vulnerability in the Linux kernel's USB gadget MIDI function (f_midi) was resolved by initializing work in the f_midi_alloc() function. The issue occurs because work initialization was previously done only in f_midi_bind(), which may not always run, leading to uninitialized work and a warning in __flush_work due to work->func being zero. This flaw was fixed by moving the INIT_WORK call to f_midi_alloc().
A vulnerability in the Linux kernel's drm/amdkfd component allows a user with CAP_CHECKPOINT_RESTORE capability to trigger a kernel NULL pointer dereference and cause a system panic. This occurs because the functions create_queue_cpsch() and create_queue_nocpsch() call a restore_mqd() callback without checking if it is NULL during a CRIU queue restore operation. The issue affects specific Linux kernel versions and is triggered only by a crafted restore payload, not by legitimate CRIU images.
A vulnerability in the Linux kernel's scsi qla2xxx driver involves improper serialization of flash version reads in the reset handler. The reset operation calls get_flash_version() without holding the ha->optrom_mutex, allowing concurrent flash register accesses that can corrupt reads. This issue has been resolved by ensuring the mutex is held during the call, matching the VPD update path.
A vulnerability in the Linux kernel's media CEC core was resolved by fixing a memory leak caused by a missed call to rc_free_device(). This issue arose after a code change removed an implicit call to rc_free_device() but failed to remove a NULL assignment, preventing proper freeing of allocated remote control devices. The leak was detected by kmemleak after device unbinding, such as with dw-hdmi. The fix involves removing the NULL assignment to allow cec_delete_adapter() to free the device correctly.
A vulnerability in the Linux kernel's BPF implementation on LoongArch architecture involving incorrect jump offset calculation in tail calls has been resolved. The issue was due to using a stale prior-pass code stride for jump distance calculation, causing wrong branch offsets and potential soft lockups during extra JIT passes. The fix recalculates the offset directly on the absolute target and adds a guard to prevent false aborts during size estimation. This vulnerability affects specific Linux kernel versions and has a CVSS score of 7.8, indicating a high impact on confidentiality, integrity, and availability.