Eclipse Ditto versions before 3.8.15 and from 3.9.0 up to 3.9.8 contain an incorrect authorization vulnerability. The policy enforcers improperly handle permission revocations in two scenarios: when checking multiple permissions simultaneously and when performing partial permission checks. This flaw can cause the system to report revoked permissions as granted, allowing a requester to discover the existence of Things and Policies and receive metadata without readable content. However, the actual content filtering and modification controls remain effective.
Eclipse Ditto versions 2.0.0 through 3.8.14 and 3.9.0 through 3.9.8 contain an authorization flaw in the handling of JSON merge patch commands. The authorization check fails to verify permissions for fields deleted or set to empty objects by the patch, allowing authenticated users with WRITE permission on any part of a Thing to delete or overwrite attributes, features, or definitions beyond their granted permissions.
Eclipse Ditto versions 3.9.0 through 3.9.8 contain an authorization flaw in the resolved policy view API endpoint. This flaw allows an authenticated user with read access on a policy to access merged policy content, including imported and namespace-root entries, that they should not be authorized to see. The issue arises because the merged policy content is not properly restricted based on the caller's permissions, exposing subjects, resources, and permissions that are otherwise hidden or explicitly revoked in the originating policy. The vulnerability is fixed in version 3.9.9.
MISP versions up to 2.5.51 have a vulnerability in the cryptographic signature verification process for protected events. The flaw allows an attacker positioned on the network between MISP instances to inject whitespace into JSON keys or identifier values without invalidating the PGP signature, enabling modification of event content while still passing signature verification. This undermines the integrity of protected event synchronization. The issue affects event creation, editing, viewing, and server-to-server synchronization. The fix, introduced in MISP 3.0, adds a post-verification check rejecting whitespace in keys and identifiers and implements an exact-byte signature scheme to prevent whitespace normalization attacks while maintaining backward compatibility with older instances.
Eclipse Ditto versions 2.4.0 through 3.9.8 contain an authorization flaw that allows authenticated users to read Thing fields they are not permitted to access. This occurs due to improper authorization checks on the 'condition' and 'live-channel-condition' headers in Thing query commands and WoT Thing Description requests. The flaw results in unauthorized disclosure of Thing data fields, sometimes without any permission required.
Goproxy versions before 1.9.4 have a vulnerability in their pseudo-random number generator used for key generation. This flaw allows attackers who possess the CA certificate and one leaf certificate to regenerate the leaf's private key, enabling impersonation of the host to clients trusting the proxy CA. The issue is due to misuse of hash.Sum in the key derivation process. A fix is available in version 1.9.4.
CVE-2026-132039 is an authorization vulnerability in Eclipse Ditto versions before 3.9.9. It allows authenticated subscribers with partial READ access to a Thing to receive event data containing field values they are not authorized to read. This occurs because the system does not properly apply READ revokes across multiple subjects in the subscriber's authorization context, causing unfiltered event data to be disclosed via WebSocket, Server-Sent Events, and related connections.
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 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: 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: 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:
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:
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:
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:
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.
MISP contains an authorization and input-validation flaw in its event push mechanism. When a user with push permissions initiates a push of events to a remote MISP instance, the system fails to enforce two critical checks: (1) it does not verify that an event is published before including it in the push, allowing unpublished (i.e., not yet publicly shared) events to be transmitted to the remote server; and (2) it does not verify that the pushing user has read access to the event, causing events the user cannot fetch to be sent as empty event shells, thereby disclosing the existence and metadata of events the user is not authorized to view. Additionally, the remote server's reply selecting which offered events to accept is used without validating that the selected identifiers actually correspond to events in the offered set, potentially allowing the remote to reference events outside the intended scope. The vulnerability requires an authenticated user with push permissions on the source MISP instance and a configured push target. The security impact is unauthorized disclosure of confidential threat-intelligence data (unpublished events and events restricted by user permissions) to a remote MISP instance that should not receive them.
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: 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: 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: 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.