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

Search

Search Results (430086 CVEs found)

CVE Vendors Products Updated CVSS v3.1
CVE-2026-99392 1 Linux 2 Linux, Linux Kernel 2026-11-20 3.4 Low
In the Linux kernel, the following vulnerability has been resolved: xfs: don't subtract excess usage twice when computing agf_btreeblks LOLLM noticed that the free space btree repair code calculates agf_btreeblks from the number of blocks we wrote to rebuild the free space btrees (minus the roots). That's correct. However, it observes that we subtract the "excess" reservation, which is not correct. Fix this accounting problem.
CVE-2026-99393 1 Linux 2 Linux, Linux Kernel 2026-11-20 4.4 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: don't overrun incore inode when cleaning attr forks LOLLM noticed that xrep_dinode_check_afork doesn't check for a di_forkoff value that is so large that the attr fork would begin after the end of the inode space. This causes afork_{ptr,size} to be nonsense. What we really ought to do here is zap the attr fork.
CVE-2026-99394 1 Linux 2 Linux, Linux Kernel 2026-11-20 6.0 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: complain loudly when dirtree checker finds broken links LOLLM observed that the directory tree walk code bails out if it finds broken parent pointers along the way. However, it flattens the return code to zero, which means that we can end up in the repair code having not completed the scan. We should never proceed with a repair in this state, so let's mark the scrub incomplete and exit.
CVE-2026-99395 1 Linux 2 Linux, Linux Kernel 2026-11-20 6.7 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: bound inode fork length against the fork size during log recovery xlog_recover_inode_commit_pass2() copies an inode log item's data/attr fork region into the inode buffer using the on-log region length without bounding it against the fork capacity, e.g.: len = item->ri_buf[2].iov_len; memcpy(XFS_DFORK_DPTR(dip), src, len); The only guard is an ASSERT, which is a no-op on production kernels (CONFIG_XFS_DEBUG off), and xfs_dinode_verify() runs only after the copy. A crafted image with a dirty log can therefore drive a heap out-of-bounds write at mount time. The XFS_ILOG_DBROOT sibling already passes XFS_DFORK_DSIZE as a bound; the DDATA/DEXT and ADATA/AEXT memcpy paths did not. Bound each logged fork region against the destination fork size before copying it, and reject the log item with -EFSCORRUPTED when it does not fit. Because the recovered inode is only verified after the fork data has been copied in, the checks are done up front, before any memcpy into the on-disk inode.
CVE-2026-99396 1 Linux 2 Linux, Linux Kernel 2026-11-20 4.4 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: bound da-node entry count against the correct geometry xfs_da3_node_verify() bounds the node entry count against the larger of the directory and attribute geometries because, as a buffer verifier, it cannot tell whether the block belongs to the directory or the attribute tree. When the directory block size exceeds the fs block size (e.g. mkfs.xfs -n size=64k -b size=4k), an attribute node buffer is a single fs block that holds only m_attr_geo->node_ents entries, yet a crafted attr node may claim a count up to m_dir_geo->node_ents and still pass the verifier. xfs_da3_node_lookup_int() then indexes btree[] up to that count during its binary search -- an out-of-bounds read via getxattr/listxattr on a mounted crafted image. The buffer verifier is the wrong place to tighten this: it has no fork context, and the transaction-less read path used by getxattr does not run xfs_da3_node_set_type() either. xfs_da3_node_lookup_int(), on the other hand, always runs on that path and holds args->geo, the geometry of the fork actually being searched. Bound the entry count against args->geo->node_ents there, before walking the entries.
CVE-2026-99397 1 Linux 2 Linux, Linux Kernel 2026-11-20 N/A
In the Linux kernel, the following vulnerability has been resolved: xfs: always report inode repair setup failures LOLLM noticed that xchk_setup_inode silently discards errors being returned by xrep_setup_inode. Fix that, and fix the stub macro so that it actually "returns" a value.
CVE-2026-99398 1 Linux 2 Linux, Linux Kernel 2026-11-20 3.6 Low
In the Linux kernel, the following vulnerability has been resolved: xfs: always forget cached ACLs if the attr fork swap succeeds LOLLM complains that xrep_xattr_rebuild_tree omits the xfs_forget_acl call if the attr fork swap succeeds (and hence the acls might have changed) but reaping the old attr fork fails. Fix it so that we always purge the cached acls if the swap succeeds, even if subsequent steps do not. This avoids some cache coherency problems with access controls.
CVE-2026-99399 1 Linux 2 Linux, Linux Kernel 2026-11-20 6.7 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: reject remote xattr entries with an out-of-range value length xfs_attr3_leaf_verify_entry() validates a remote attribute entry's name but never bounds its on-disk value length (xfs_attr_leaf_name_remote. valuelen, a __be32). A crafted leaf with valuelen = 0x80000000 passes the verifier and the CRC. That length is later assigned into the signed int args->rmtvaluelen (xfs_attr3_leaf_getvalue), becoming negative, which slips past the signed -ERANGE check in xfs_attr_copy_value(); a getxattr() with a small buffer then memcpy()s a full remote block into the small kvalue buffer (xfs_attr_rmtval_copyout) -- a heap out-of-bounds write with attacker-controlled content, from an unprivileged getxattr(2) on a mounted crafted image. Reject remote entries whose value length exceeds XFS_XATTR_SIZE_MAX in the leaf verifier, so the malicious block is rejected at read time.
CVE-2026-99400 1 Linux 2 Linux, Linux Kernel 2026-11-20 6.7 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: reject out-of-range attribute value lengths in xfs_attr_copy_value xfs_attr_copy_value() takes the value length as a signed int and, for a remote xattr, is handed args->rmtvaluelen. That field is filled from the on-disk __be32 xfs_attr_leaf_name_remote.valuelen in xfs_attr3_leaf_getvalue(), so a crafted length such as 0x80000000 is stored into the signed rmtvaluelen as a negative number. The "buffer too small" guard in xfs_attr_copy_value() is a signed comparison: if (args->valuelen < valuelen) return -ERANGE; A negative valuelen therefore compares as smaller than the caller's buffer size, skips the -ERANGE path, and is then used as a copy length, leading to an out-of-bounds copy of a full remote block into a small getxattr(2) buffer on a mounted crafted image. Reject a value length that is negative or larger than the maximum xattr size before it is used, so a bogus on-disk length can no longer slip through the value copier.
CVE-2026-99401 1 Linux 2 Linux, Linux Kernel 2026-11-20 4.7 Medium
In the Linux kernel, the following vulnerability has been resolved: rtnetlink: wait for RCU readers in rtnl_link_unregister() rtnl_link_ops_get() finds ops on link_ops under rcu_read_lock() and only then takes ops->srcu. rtnl_link_unregister() unlinks ops, then calls synchronize_srcu() and cleanup_srcu_struct() without first waiting for RCU readers. A reader that found ops before list_del_rcu() and has not yet taken ops->srcu is not waited for. Such a reader then locks a cleaned-up srcu_struct and keeps using ops after the module that owns it is gone. rtnl_newlink() and rtnl_dump_ifinfo() both look up ops without RTNL, the latter for any user that dumps links filtered by kind. With delays added between the lookup and srcu_read_lock() in rtnl_link_ops_get(), and before rtnl_link_ops_put() in rtnl_dump_ifinfo(), running "ip link show type dummy" alongside "rmmod dummy" on a KASAN kernel gives: BUG: KASAN: vmalloc-out-of-bounds in __srcu_read_unlock+0x57/0x70 Read of size 8 at addr ffffffffc02ff318 by task ip/147 Call Trace: __srcu_read_unlock+0x57/0x70 rtnl_dump_ifinfo.cold+0x30/0x3b rtnl_dumpit+0x7a/0x1b0 netlink_dump+0x486/0x11b0 __netlink_dump_start+0x661/0x910 rtnetlink_rcv_msg+0x611/0x9e0 netlink_rcv_skb+0x126/0x380 netlink_unicast+0x605/0x830 netlink_sendmsg+0x6d0/0xbb0 __sys_sendto+0x335/0x3a0 Call synchronize_rcu() before synchronize_srcu(), as rtnl_af_unregister() already does. This should be enough because rtnl_link_ops_get() is the only RCU walker of link_ops, and it takes ops->srcu before rcu_read_unlock(), so every reader that found ops is covered by synchronize_srcu() once the RCU grace period ends. The extra grace period only costs time at module unload. Readers and the writer were serialized by RTNL until link_ops got its own mutex, which is why the missing RCU wait did not matter before.
CVE-2026-99402 1 Linux 2 Linux, Linux Kernel 2026-11-20 5.5 Medium
In the Linux kernel, the following vulnerability has been resolved: netfilter: nft_payload: restrict checksum offsets to known values We need to prevent userspace from corrupting e.g. tcp->doff, because many locations in conntrack and conntrack helpers rely on nf_conntrack_in() having validated the packet headers. nft_payload allows to alter headers later which invalidates this assumption. The 'Fixes' commit restricts writes to safe fields, but there is another side channel: the checksum location. Restrict this too. Reported via sashiko/gemini.
CVE-2026-99403 1 Linux 2 Linux, Linux Kernel 2026-11-20 4.4 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: mark overfull dabtree node blocks as corrupt LOLLM observes that we need to range-check the dabtree node record count before using it to index an array. Fix that.
CVE-2026-99404 1 Linux 2 Linux, Linux Kernel 2026-11-20 N/A
In the Linux kernel, the following vulnerability has been resolved: xfs: check fork type against dabtree block magic number LOLLM complains that we fail to flag dabtree blocks that should never be associated with the file fork -- data forks can't point to xattr leaves, and attr forks can't point to dirent blocks. Add the missing checks.
CVE-2026-99405 1 Linux 2 Linux, Linux Kernel 2026-11-20 5.7 Medium
In the Linux kernel, the following vulnerability has been resolved: xfs: abort dirtree repair if the live update hook dies LOLLM notices that if the live update hook for the directory tree repair code hits an error, it will set dl->aborted and stops working. If the repair code ever sees that condition, it ought to bail out immediately instead of continuing with obsolete data.
CVE-2026-99406 1 Linux 2 Linux, Linux Kernel 2026-11-20 N/A
In the Linux kernel, the following vulnerability has been resolved: xfs: fix lost errno returned from xfarray_foliosort LOLLM noticed that we stop the sort early but don't actually pass along the error code, which could enable repair code to continue running with an unsorted array. Fix that.
CVE-2026-132039 1 Eclipse 1 Eclipse Ditto 2026-11-20 N/A
In Eclipse Ditto versions before 3.9.9, Thing events delivered via WebSocket, Server-Sent Events and connections disclose field values which the policy does not allow the subscriber to read. A READ revoke for one subject of the subscriber's authorization context is not applied when another of its subjects is granted READ. For subscribers with partial READ access, subscription RQL filters, the SSE `_context`, `thing-json` placeholders and extra fields are evaluated on the unfiltered event. This allows an authenticated subscriber with at least partial READ access to a Thing to obtain the values of fields it may not read when events for that Thing are emitted.
CVE-2026-129700 1 Eclipse 1 Eclipse Ditto 2026-11-20 N/A
In Eclipse Ditto versions 2.4.0 to 3.9.8, Thing fields a requester is not allowed to read can be disclosed through the `condition` and `live-channel-condition` headers, which are evaluated against the full Thing: the READ check of `live-channel-condition` is skipped when a `condition` header is also present on Thing query commands (3.0.0 to 3.9.8); both headers are evaluated without any authorization on WoT Thing Description requests (`Accept: application/td+json`) when WoT TD permission filtering is not active (by default in 3.0.0 to 3.8.14, in 2.4.x with WoT integration enabled, and in 3.9.x with filtering disabled); the `condition` of live messages and live events is evaluated without a READ check, and of claim messages without any permission (3.1.0 to 3.9.8); and the twin response of a Thing query with a non-matching `live-channel-condition` is returned without filtering it by the policy (3.0.0 to 3.9.8). This allows an authenticated user to read Thing fields they are not allowed to read, in some cases without any permission on the Thing.
CVE-2026-129916 1 Eclipse 1 Eclipse Ditto 2026-11-20 N/A
In Eclipse Ditto versions 3.9.0 to 3.9.8, the resolved policy view (`GET /api/2/policies/{policyId}?policy-view=resolved`) does not restrict merged policy content to what the caller may read in the policy it originates from. Imported and namespace-root entries are returned in full as soon as the caller may read any part of them in the source policy, entries of transitive imports and of the imports of namespace-root policies are only checked against the intermediate policy, and content copied into an entry by `references`, also from another entry of the same policy, is not checked against the referenced entry. An authenticated caller with READ on a policy can therefore read subjects, resources and granted/revoked permissions of policy entries that are hidden from them, including by explicit revokes, when reading the originating policy directly.
CVE-2026-129699 1 Eclipse 1 Eclipse Ditto 2026-11-20 N/A
In Eclipse Ditto versions 2.0.0 to 3.8.14 and 3.9.0 to 3.9.8, the authorization check for JSON merge patch commands on Things (HTTP `PATCH` / Ditto Protocol `merge`) does not check permissions for fields deleted or set to an empty object by the patch: fields with a `null` value or an empty object value (`{}`) are skipped by the check, and Ditto's regex-based key deletion with the documented `{{ ~<regex>~ }}` syntax is not recognized as a deletion. An authenticated user with WRITE permission on any part of a Thing can therefore delete other attributes, features and the definition of that Thing, or overwrite or create fields as empty objects, including parts the policy revokes or never grants WRITE on. -->
CVE-2026-129702 1 Eclipse 1 Eclipse Ditto 2026-11-20 N/A
In Eclipse Ditto versions before 3.8.15 and 3.9.0 to 3.9.8, the policy enforcers do not let a revoke win over a grant in two kinds of permission checks. Checks of several permissions at once compare the highest grant weight with the highest revoke weight across all requested permissions instead of per permission, so the "check permissions" API (`POST /api/2/checkPermissions`, available since 3.7.0) can report a set of permissions as granted although one of them is revoked. Partial permission checks, which authorize retrieving Things and Policies and determine the receivers of events, count a grant on a sub-resource although the same permission is revoked on that sub-resource for another subject of the same authorization context (or, with the memory-optimized policy evaluator, for the same subject). A requester can thereby learn about the existence of Things and Policies and receive metadata without any readable content, and an application relying on the check permissions result may grant access the policy denies. The content of retrieved Things and Policies is still filtered correctly, and modifications are not affected.