In the Linux kernel, the following vulnerability has been resolved:

bcachefs: grab sumount only if snapshotting

When I was testing mongodb over bcachefs with compression, there is a lockdep warning when snapshotting mongodb data volume.

$ cat test.sh prog=bcachefs

$prog subvolume create /mnt/data $prog subvolume create /mnt/data/snapshots

while true;do $prog subvolume snapshot /mnt/data /mnt/data/snapshots/$(date +%s) sleep 1s done

$ cat /etc/mongodb.conf systemLog: destination: file logAppend: true path: /mnt/data/mongod.log

storage: dbPath: /mnt/data/

lockdep reports: [ 3437.452330] ====================================================== [ 3437.452750] WARNING: possible circular locking dependency detected [ 3437.453168] 6.7.0-rc7-custom+ #85 Tainted: G E [ 3437.453562] ------------------------------------------------------ [ 3437.453981] bcachefs/35533 is trying to acquire lock: [ 3437.454325] ffffa0a02b2b1418 (sbwriters#10){.+.+}-{0:0}, at: filenamecreate+0x62/0x190 [ 3437.454875] but task is already holding lock: [ 3437.455268] ffffa0a02b2b10e0 (&type->sumountkey#48){.+.+}-{3:3}, at: bch2fsfileioctl+0x232/0xc90 [bcachefs] [ 3437.456009] which lock already depends on the new lock.

[ 3437.456553] the existing dependency chain (in reverse order) is: [ 3437.457054] -> #3 (&type->sumountkey#48){.+.+}-{3:3}: [ 3437.457507] downread+0x3e/0x170 [ 3437.457772] bch2fsfileioctl+0x232/0xc90 [bcachefs] [ 3437.458206] x64sysioctl+0x93/0xd0 [ 3437.458498] dosyscall64+0x42/0xf0 [ 3437.458779] entrySYSCALL64afterhwframe+0x6e/0x76 [ 3437.459155] -> #2 (&c->snapshotcreatelock){++++}-{3:3}: [ 3437.459615] downread+0x3e/0x170 [ 3437.459878] bch2truncate+0x82/0x110 [bcachefs] [ 3437.460276] bchfstruncate+0x254/0x3c0 [bcachefs] [ 3437.460686] notifychange+0x1f1/0x4a0 [ 3437.461283] dotruncate+0x7f/0xd0 [ 3437.461555] pathopenat+0xa57/0xce0 [ 3437.461836] dofilpopen+0xb4/0x160 [ 3437.462116] dosysopenat2+0x91/0xc0 [ 3437.462402] x64sysopenat+0x53/0xa0 [ 3437.462701] dosyscall64+0x42/0xf0 [ 3437.462982] entrySYSCALL64afterhwframe+0x6e/0x76 [ 3437.463359] -> #1 (&sb->stype->imutexkey#15){+.+.}-{3:3}: [ 3437.463843] downwrite+0x3b/0xc0 [ 3437.464223] bch2writeiter+0x5b/0xcc0 [bcachefs] [ 3437.464493] vfswrite+0x21b/0x4c0 [ 3437.464653] ksyswrite+0x69/0xf0 [ 3437.464839] dosyscall64+0x42/0xf0 [ 3437.465009] entrySYSCALL64afterhwframe+0x6e/0x76 [ 3437.465231] -> #0 (sbwriters#10){.+.+}-{0:0}: [ 3437.465471] lockacquire+0x1455/0x21b0 [ 3437.465656] lockacquire+0xc6/0x2b0 [ 3437.465822] mntwantwrite+0x46/0x1a0 [ 3437.465996] filenamecreate+0x62/0x190 [ 3437.466175] userpathcreate+0x2d/0x50 [ 3437.466352] bch2fsfileioctl+0x2ec/0xc90 [bcachefs] [ 3437.466617] x64sysioctl+0x93/0xd0 [ 3437.466791] dosyscall64+0x42/0xf0 [ 3437.466957] entrySYSCALL64afterhwframe+0x6e/0x76 [ 3437.467180] other info that might help us debug this:

[ 3437.469670] 2 locks held by bcachefs/35533: other info that might help us debug this:

[ 3437.467507] Chain exists of: sbwriters#10 --> &c->snapshotcreatelock --> &type->sumountkey#48

[ 3437.467979] Possible unsafe locking scenario:

[ 3437.468223] CPU0 CPU1 [ 3437.468405] ---- ---- [ 3437.468585] rlock(&type->sumountkey#48); [ 3437.468758] lock(&c->snapshotcreatelock); [ 3437.469030] lock(&type->sumountkey#48); [ 3437.469291] rlock(sbwriters#10); [ 3437.469434] DEADLOCK

[ 3437.469 ---truncated---

An authenticated user with basic write privileges can cause the mongod process to terminate abnormally by sending a crafted transaction command with an incomplete set of required fields. The issue stems from inconsistent validation across related transaction command parameters, resulting in a fatal internal invariant failure and denial of service.

Using expressions that generate large arrays it is possible to craft a query that creates very large intermediate objects in memory, causing the server to crash with OOM error.

The $internalIndexKey aggregation expression can be used by any authenticated user to crash a MongoDB server (mongod). The expression fails to handle compound wildcard index specifications, triggering an internal consistency check that aborts the server process. The user must be able to run an aggregation pipeline.

An authenticated user with limited read privileges may be able to access documents from collections they are not authorized to read, due to an inconsistency in how the $graphLookup aggregation stage is evaluated during authorization and during execution. Affected scenarios involve collections referenced within existing view pipeline definitions.

An authenticated user may be able to view session metadata belonging to other users on the system through the $listSessions aggregation stage. This information is normally restricted to users with cluster-level administrative privileges, and includes active session identifiers, associated usernames, and activity timestamps.

An authenticated user with low privileges may be able to perform unauthorized reads and writes on data protected by role-based query-level access controls, due to insufficient validation of certain client-supplied command parameters. The issue affects find, update, delete, and aggregate commands in non-apiStrict configurations.

An issue in the server’s Atlas Search integration allows an authenticated user to bypass per-user access controls.

In sharded topologies, the $search and $searchMeta aggregation stages use internal routing that is normally populated only by the trusted router during sharded search planning. Due to insufficient input validation, an authenticated client can supply these fields directly.

Improper handling of DBPointer objects during BSON serialization in MongoDB's server-side JavaScript engine can result in internal process memory contents being included in data returned to the client. This constitutes an unintended information disclosure affecting deployments that use server-side JavaScript.

An unauthenticated remote client can cause excessive CPU consumption on a MongoDB server by sending a specific combination of parameters to the awaitable hello command in exhaust mode. The server's handling of this combination results in a response loop that bypasses normal throttling, allowing a small number of connections to degrade server availability.

When compute mode is enabled on a standalone mongod instance, insufficient validation of externally sourced BSON data during aggregation pipeline processing can result in memory corruption, potentially leading to process termination or other unintended behavior. This configuration is non-default and requires explicit enablement at startup.

An authenticated user with write privileges on a Queryable Encryption-enabled collection may be able to modify internal encryption metadata fields that are intended to be server-controlled, by sending crafted write commands through the mongos router on a sharded cluster. This can result in corruption of encrypted query correctness.

An authenticated user can cause excessive CPU consumption or out-of-memory conditions on a MongoDB server by sending a crafted Queryable Encryption find payload containing an unvalidated field used to control an internal computation loop. The resulting resource exhaustion degrades availability for other operations.

A user with read-only privileges is able to craft an aggregation pipeline using the $linearFill window function operator with a specific sortBy expression type to cause the mongod process to terminate abnormally, resulting in denial of service. The issue stems from insufficient validation of sort specifications during execution.

A missing bounds check in the BSON CodeWScope element accessors allows an attacker to trigger an out-of-bounds heap read via a crafted aggregation pipeline. The vulnerability can be exploited by an authenticated user by generating a malformed BSONColumn data containing a CodeWScope element, bypassing wire-level BSON validation. When the forged element is decompressed, the unchecked size value is used in pointer arithmetic, causing either a server crash or disclosure of adjacent heap memory contents.

When PROXY protocol v2 is used on the Unix domain socket path, roles derived from X.509 client certificates may not be validated against the configured tlsCATrusts allow-list. This can result in unintended role assignments following MONGODB-X509 authentication. Affected scenarios require local access to the proxy Unix domain socket and a valid X.509 certificate issued by a trusted certificate authority.

An authenticated user with standard read/write privileges can cause the mongod process to terminate due to an out-of-memory condition by sending a crafted aggregation command. MongoDB's libmongocrypt library insufficiently validates payload-supplied values, which can result in an excessively large memory allocation.

An authenticated user with read-only privileges can cause the mongod process to terminate abnormally by issuing a crafted aggregation command, resulting in denial of service for all connected clients until the process is restarted. The issue stems from an internal engine selection inconsistency triggered by a specific combination of aggregation options.

A vulnerability was discovered in MongoDB Server where the server-side MozJS scripting engine unconditionally registered a module loading hook that enables JavaScript calls to read arbitrary files from the host filesystem using the mongod process's privileges. An authenticated user could exploit this through crafted aggregation pipeline commands to read sensitive files accessible to the MongoDB server process.

An authenticated user holding cursor termination privileges on one database may incorrectly be permitted to terminate active cursors on a separate database, disrupting ongoing query operations for other users. The behavior stems from an authorization check that does not correctly scope privileges to the appropriate namespace.

An authenticated user with read access can cause the mongod process to be terminated through certain aggregation expressions that execute server-side JavaScript. The issue involves improper memory handling during document processing.

During query planning when reading the sort pattern in raw BSONObj form, in some places we don’t explicitly handle the meta expression case. This may lead to incorrect transformations leading to invariant failure.

An authenticated user can cause the mongod process to be terminated by the operating system under memory pressure via the $rankFusion and $scoreFusion aggregation stages. The issue originates in the server's error-handling path and requires the ability to run aggregation queries.

An authenticated user can cause a {{mongod}} process to be terminated by the operating system under memory pressure by performing a specific data type conversion operation within MongoDB's aggregation framework. The behavior stems from disproportionate memory consumption during this operation, and requires both write access to the database and the ability to run aggregation queries.

A MongoDB server initiating an outbound TLS connection may terminate abnormally when processing a malformed OCSP response from a remote peer during the TLS handshake. OCSP stapling validation is enabled by default for outgoing TLS connections. Affected scenarios require the remote peer to hold a certificate issued by the cluster's trusted certificate authority, or for the connection to traverse an untrusted network path.

Certain query operations involving deeply nested $jsonSchema constructs can trigger disproportionate CPU consumption in affected MongoDB deployments, potentially leading to resource exhaustion. The resulting CPU-bound operation cannot be interrupted through standard administrative controls.

MongoDB Server's handling of a Queryable Encryption maintenance operation did not properly validate certain request parameters against the collection's encrypted field configuration before use. An authenticated user with readWrite privileges could submit a specially formed request that leads to a server crash or excessive internal writes, resulting in resource exhaustion and corruption of encrypted index data.

An issue in MongoDB Server's $graphLookup aggregation stage could allow an authenticated user able to issue aggregation and memory-management commands to cause an internal reference to be used after the underlying memory has been freed. This could result in a server crash or, potentially, execution of unintended code.

An issue in MongoDB Server could allow a party with a valid client certificate and a corresponding user account to authenticate using a certificate-based authentication method, even when an administrator has configured the server to restrict authentication to other mechanisms. This could allow authentication through a method the administrator intended to disable.

An issue in MongoDB Server's handling of certain query predicates against time-series collections with a metaField could allow an authenticated user with write access to cause the server process to terminate unexpectedly, resulting in a denial of service.