Export limit exceeded: 429892 CVEs match your query. Please refine your search to export 10,000 CVEs or fewer.

Search vulnerabilities

Results 429,892

Export CSV
CVE-2026-125707

Gst-plugins-bad: gst-plugins-bad: off-by-one write in mxf demuxer temporal offset table

A flaw was found in GStreamer's MXF demuxer. When an application processes a crafted MXF file, an off-by-one bounds check can allow a one-byte write past the logical end of a temporal offset array. This may corrupt memory and cause the application to crash. The extent of the impact has not been demonstrated by a runtime test.

CVSS 3.1 · 7.1 High EPSS < 1% KEV · Not listed
Vendors
CVE-2026-133611

vulnerability-lookup: 2FA Disabled via Unauthenticated GET Request and Unpublished Comments Accessible Without Authorization

vulnerability-lookup prior to version 7.1.0 contains two security issues in its web interface. First, the /user/toggle_2fa endpoint accepted HTTP GET requests and disabled the authenticated user's two-factor authentication without requiring password confirmation. Because the state-changing operation was reachable via GET, an attacker with a basic account could embed an image element (or any other GET-triggering markup) in a comment pointing to that endpoint. When a victim with 2FA enabled viewed the comment, their browser silently issued the GET request, disabling the victim's second factor of authentication. No CSRF token was enforced on the GET path, and no password was required to confirm the action. Second, the comment detail page (/comment/<uuid>) rendered unpublished comments to any visitor who possessed the URL, bypassing the moderation workflow that was intended to keep such content hidden until approved. The API correctly restricted access, but the web view did not enforce the same authorization check. The combined effect allows an attacker to degrade a victim's account security (removal of 2FA) through a single page view and to read content that was not yet approved for public release.

CVSS 4.0 · 4.6 Medium EPSS n/a KEV · Not listed
CVE-2026-133577

Github.com/kuadrant/kuadrant-operator: github.com/kuadrant/wasm-shim: kuadrant-operator: authpolicy is silently bypassed (fail-open) when a tokenratelimitpolicy is combined with an authpolicy or a gateway-level ratelimitpolicy

A flaw was found in the Kuadrant WebAssembly (WASM) shim shipped in Red Hat Connectivity Link 1.5. When a TokenRateLimitPolicy is attached to an HTTPRoute that also has an AuthPolicy - or when a RateLimitPolicy with defaults or overrides is attached to the Gateway or listener of such routes - the shim's action pipeline fails to dispatch the authentication guard at request time, and the request is forwarded upstream. Unauthenticated requests return 200 OK instead of 401, and neither authentication nor rate limiting is enforced. Both policies continue to report Enforced, leaving no status-level indication of the failure.

CVSS 3.1 · 7.7 High EPSS n/a KEV · Not listed
Vendors
CVE-2026-16118

Xdgmime: heap-based buffer overflow in _xdg_mime_magic_parse_magic_line() in xdgmimemagic.c

A flaw was found in xdgmime. A heap-based buffer overflow can be triggered in _xdg_mime_magic_parse_magic_line() in the xdgmimemagic.c file on little-endian systems when an attacker-controlled MIME magic file in a user-writable XDG data location (e.g., in the $XDG_DATA_HOME/mime/magic path) is parsed by an application performing MIME type detection (e.g., via g_content_type_guess()). When performing byte-swap, incorrect pointer arithmetic on the write side causes an out-of-bounds write of 2 bytes, resulting in an application crash or memory corruption.

CVSS 3.1 · 7.1 High EPSS < 1% KEV · Not listed
Vendors
CVE-2026-133496

Matthias-Wandel jhead PNG Section pngfile.c RemovePngSection double free

A security vulnerability has been detected in Matthias-Wandel jhead up to 3.3. This affects the function RemovePngSectionByType/RemovePngSection of the file src/pngfile.c of the component PNG Section Handler. The manipulation leads to double free. Remote exploitation of the attack is possible. The exploit has been disclosed publicly and may be used. The project was informed of the problem early through an issue report but has not responded yet.

CVSS 4.0 · 5.3 Medium EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-71220

Gfs2-utils: gfs2-utils: stack out-of-bounds write via unchecked di_height in gfs2_edit

A stack out-of-bounds write vulnerability was found in gfs2-utils. In gfs2_edit, the di_height field from on-disk inode metadata is used as an array index without bounds checking, causing a stack buffer overflow that may lead to arbitrary code execution when processing crafted GFS2 filesystem images.

CVSS 3.1 · 7 High EPSS < 1% KEV · Not listed
Vendors
Products
CVE-2026-71221

Gfs2-utils: gfs2-utils: stack out-of-bounds write via unchecked height in savemeta

A stack out-of-bounds write vulnerability was found in gfs2-utils. In savemeta, the height value from on-disk inode metadata is used as a loop bound without bounds checking, causing a stack buffer overflow that may lead to arbitrary code execution when processing crafted GFS2 filesystem images.

CVSS 3.1 · 7 High EPSS < 1% KEV · Not listed
Vendors
Products
CVE-2026-99804

io_uring/io-wq: save worker type before dropping its reference

In the Linux kernel, the following vulnerability has been resolved: io_uring/io-wq: save worker type before dropping its reference io_wq_cancel_tw_create() inspects cb->func after calling io_worker_cancel_cb(). For an existing worker, that call can drop the last worker reference and wake io_worker_exit(). If the canceling task is preempted, the worker can be unlinked and freed by kfree_rcu() before the callback function is inspected. KASAN reports a slab-use-after-free read in this path. Save whether the callback belongs to an unpublished continuation worker while its reference is still held, then use the saved result for the conditional free. This preserves the existing accounting and frees only the worker allocated for the canceled continuation.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99803

io_uring/net: mask socket type with SOCK_TYPE_MASK in io_socket_bpf_populate()

In the Linux kernel, the following vulnerability has been resolved: io_uring/net: mask socket type with SOCK_TYPE_MASK in io_socket_bpf_populate() When an IORING_OP_SOCKET request is prepared in io_socket_prep(), sock->type retains creation flags such as SOCK_CLOEXEC and SOCK_NONBLOCK until __sys_socket_file() masks them off with SOCK_TYPE_MASK during execution. However, io_socket_bpf_populate() copies sock->type into bctx->socket.type without masking off ~SOCK_TYPE_MASK. As a result, a cBPF filter inspecting bctx->socket.type against socket types such as SOCK_DGRAM or SOCK_STREAM can be bypassed by ORing SOCK_CLOEXEC or SOCK_NONBLOCK into the socket type. Mask sock->type with SOCK_TYPE_MASK when populating bctx->socket.type.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99802

io_uring/register: enforce per-task restrictions in io_uring_register_blind()

In the Linux kernel, the following vulnerability has been resolved: io_uring/register: enforce per-task restrictions in io_uring_register_blind() When io_uring_register(2) is invoked with fd == -1, it dispatches directly to io_uring_register_blind() without checking current->io_uring_restrict. As a result, a task with per-task register restrictions installed via IORING_REGISTER_RESTRICTIONS can still invoke blind registration opcodes such as IORING_REGISTER_SEND_MSG_RING even when those opcodes are not in the task's allowed register_op bitmap. Check current->io_uring_restrict->register_op in io_uring_register_blind() before dispatching blind registration opcodes.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99801

io_uring/bpf-ops: clear bpf_ctx while submitting SQEs

In the Linux kernel, the following vulnerability has been resolved: io_uring/bpf-ops: clear bpf_ctx while submitting SQEs bpf_io_uring_submit_sqes() calls io_submit_sqes() from inside the loop program, with current->bpf_ctx set, and requests issued inline run with it set too. The socket code uses has_current_bpf_ctx() to recognize calls from bpf_setsockopt() and friends, where the caller holds the socket lock and has already been vetted, and skips both. So a SOCKET_URING_OP_SETSOCKOPT from the SQ passes sockopt_capable() without the capability, and runs without lock_sock(). A task with no capability can set SO_MARK, IP_TRANSPARENT or TCP_REPAIR, and two threads changing IP_OPTIONS on one socket, one through the ring, double free in no time. SOCK_DESTROY via IORING_OP_SENDMSG ends up in tcp_abort() without the lock the same way. Clear the run context around io_submit_sqes(). The SQEs come from userspace and must be issued like those of any other ring. They still run inside the program's RCU tasks trace read section, so a request that sleeps there holds up that grace period, but other request types do that already.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99800

io_uring: free the task context after a grace period

In the Linux kernel, the following vulnerability has been resolved: io_uring: free the task context after a grace period A task other than the owner can free a request, io_ring_exit_work() running the local task_work of a DEFER_TASKRUN ring for example, or io_do_iopoll() reaping completions. io_put_task() then takes the else branch: percpu_counter_sub(&tctx->inflight, 1); if (unlikely(atomic_read(&tctx->in_cancel))) wake_up(&tctx->wait); put_task_struct(tctx->task); The first line is what lets the owner leave io_uring_cancel_generic(), and on exec it frees the tctx right after. Nothing holds that off for the remaining three lines, the task reference only covers a tctx freed along with the task_struct. It used to work out because io_uring_del_tctx_node() took the uring_lock that the freeing side holds across io_put_task(), until that moved to tctx_lock. Free the tctx with kfree_rcu(), and enter an RCU read section in io_put_task() before the count is dropped.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99799

io_uring/sqpoll: don't wait for the thread to exit

In the Linux kernel, the following vulnerability has been resolved: io_uring/sqpoll: don't wait for the thread to exit io_sq_thread_stop() wakes the SQPOLL thread and waits for it to exit. The thread belongs to the thread group that created the ring, so a SIGSTOP or the cgroup freezer holds it in get_signal(), and the wake up doesn't change that. io_ring_exit_work() then sleeps in that wait until someone continues or kills the process. iou_exit has 64 slots, so 64 closed SQPOLL rings of a stopped process keep every other ring from being freed, for everyone. Don't wait. Set the stop bit, wake the thread, and let it exit when it gets to run again. The sqd can now outlive its last ring, so give it a second refcount with one reference for the rings and one for the thread, and free it with the last one. The thread can't reach a freed ring, rings leave ctx_list before dropping their reference, and the io-wq hash is refcounted.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99798

io_uring: defer foreign io-wq enqueues to task_work

In the Linux kernel, the following vulnerability has been resolved: io_uring: defer foreign io-wq enqueues to task_work An IOPOLL ring without DEFER_TASKRUN can be reaped by a task other than the one that submitted the I/O. If a polled request is marked REQ_F_REISSUE, io_free_batch_list() calls io_queue_iowq() with the original tctx. Ordinary task exit can tear down tctx->io_wq after draining only the tracked requests. The live request pins the task, but not its io-wq, so the foreign task can race io_wq_put_and_exit() and enqueue through a freed or NULL queue. Forward foreign userspace enqueues to the owning task before accessing tctx->io_wq. Use a dedicated task_work callback so reissues still go straight to io-wq, and fail them if task_work is running in cancellation mode. Preserve the existing PF_KTHREAD cancellation path. This also covers the other callers of io_queue_iowq() without changing the worker-owned enqueue path.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99797

io_uring/cancel: drop sqd->lock while SQPOLL waits

In the Linux kernel, the following vulnerability has been resolved: io_uring/cancel: drop sqd->lock while SQPOLL waits An exiting SQPOLL thread calls io_uring_cancel_generic() with sqd->lock held, and keeps it across cond_resched() and the sleep until nothing is in flight anymore. A zero-copy send notification can't be canceled and stays pending as long as the peer doesn't read, so the lock is held for as long as a user cares to. io_ring_exit_work() needs it to park the thread, and so do IORING_REGISTER_IOWQ_AFF and IOWQ_MAX_WORKERS. With 64 such rings sharing the thread, every iou_exit slot sleeps on the lock and no ring gets freed for anyone. Drop the lock around cond_resched() and the sleep, like the main loop of the thread does. Each walk of ctx_list is still under one hold, and nothing is kept across the unlock. The thread drops its io-wq, frees its tctx and clears sqd->thread under one hold after the loop, so whoever holds the lock and finds sqd->thread set can still use them. [axboe: adapted to the schedule_timeout() based loop]

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-99796

io_uring/poll: cancel all matching requests in one pass

In the Linux kernel, the following vulnerability has been resolved: io_uring/poll: cancel all matching requests in one pass With IORING_ASYNC_CANCEL_ALL, __io_async_cancel() calls io_try_cancel() until nothing is found, and io_poll_cancel() cancels one request per call, starting each lookup at the beginning of the hash. A cancelled request stays hashed until its task work runs, so every lookup walks past the ones already cancelled. Cancelling K of N pending polls visits about K*N/2 requests in one io_uring_enter(), with uring_lock held. A single CANCEL_FD|ALL on 80000 polls on one eventfd takes 17.06s, 0.02s with this change. With voluntary preemption the soft lockup watchdog fires: watchdog: BUG: soft lockup - CPU#1 stuck for 26s! [repro:100] RIP: 0010:io_cancel_req_match+0x19/0xa0 io_poll_cancel+0x73/0x170 io_try_cancel+0x7b/0xf0 __io_async_cancel+0x41/0x110 Walk the hash once and cancel every match, as io_cancel_remove() does for futex and waitid. Cancel by user_data only needs its own bucket. __io_async_cancel() still loops until nothing is found, so a request that io-wq parks in the poll hash meanwhile is still cancelled. A cancel that matches one request now walks the whole hash twice instead of stopping at the match.

CVSS n/a EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-133495

D-Link DIR-600L fatlady hedwig.cgi path traversal

A weakness has been identified in D-Link DIR-600L 2.17b02. Affected by this issue is some unknown functionality of the file hedwig.cgi of the component fatlady Handler. Executing a manipulation can lead to path traversal. The attack may be launched remotely.

CVSS 4.0 · 6.9 Medium EPSS n/a KEV · Not listed
Vendors
Products
CVE-2026-129972

A buffer overflow vulnerability exists in the web management service of the Ethernet Remote I/Os products. An unauthenticated remote attacker could exploit insufficient bounds checking of specially crafted HTTP requests, potentially causing the web management service to crash and resulting in a denial-of-service condition.

CVSS 4.0 · 8.7 High EPSS n/a KEV · Not listed
Vendors
CVE-2026-129971

A buffer overflow vulnerability exists in the SNMP service of the Ethernet Remote I/Os products. An unauthenticated remote attacker could exploit improper handling of specially crafted SNMP requests, potentially leading to a denial-of-service condition on the affected device.

CVSS 4.0 · 8.7 High EPSS n/a KEV · Not listed
Vendors
CVE-2026-47066

Infinite loop in Alt-Svc header parser in hackney

Loop with Unreachable Exit Condition ('Infinite Loop') vulnerability in benoitc hackney allows Excessive Allocation. The Alt-Svc response header parser in src/hackney_altsvc.erl does not guarantee forward progress. When parse_token/2 receives a non-token, non-whitespace, non-comma byte (e.g. !, @, =, ;), it returns the input unchanged. skip_comma/1 also returns the buffer unchanged when the first byte is not a comma. parse_entries/2 then recurses with identical data, creating a tight infinite tail-recursive loop that pins a scheduler at 100% CPU. The calling process never returns. The entry point parse_and_cache/3 is called synchronously in the connection process on every HTTP response. A single-byte Alt-Svc: ! response header is sufficient to trigger the hang; the header is fully controlled by any HTTP origin the client connects to. This issue affects hackney: from 2.0.0-beta.1 before 4.0.1.

CVSS 4.0 · 8.7 High EPSS < 1% KEV · Not listed
Vendors
Products