| CVE |
Vendors |
Products |
Updated |
CVSS v3.1 |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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.
--> |
| 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. |
| In the Linux kernel, the following vulnerability has been resolved:
xfs: don't repair fs summary counters with garbage
LOLLM noticed that if we scan the filesystem and come up with totally
garbage numbers for the summary counters, we don't actually mark the
scan incomplete. Because we don't do this, repair can install the
garbage values into the filesystem, making things worse. Don't do that. |