Threats tagged 'ghsa-8mx5-7m5m-r77g'

filelock on Windows ignores the `mode` argument. `FileLock(path, mode=0o600)` creates the same file as `FileLock(path)`: one with no security descriptor of its own (the Windows record that says who may access a file). Its access list, or ACL, is whatever the lock directory hands down to new files. filelock creates the `ReadWriteLock` database, which it asks to be `0o600`, the same way. In a directory whose inheritable ACL grants other local accounts access to new files, those accounts can open the lock file or database. They can take the byte-range lock (a lock on a span of bytes in a file) once the owner releases it and keep the owner's later `acquire()` calls waiting or timing out. They can read holder metadata an `on_acquired` hook left in a `preserve_lock_file=True` file. Where the directory hands down modify access, they can write to both files. `lock.mode` still reports `0o600`. The documentation neither promises an ACL on Windows nor says that Windows drops the mode. On Unix the same mode keeps other accounts out. Mutual exclusion between processes that follow the protocol holds on either platform. Affected versions are filelock 3.10.0 through 4.2.0 on Windows. Anthropic's OSS Scanner reported this in private. Finding covered by this advisory: - `ANT-2026-0KEO0DDO` [medium, CWE-732]: WindowsFileLock ignores mode; 0o600 lock files inherit the directory ACL. ## Severity **CVSS 3.1 `CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L` scores 5.3 (Medium).** `AV:L` (local): the other account needs a logon on the same host. `PR:L` (low privileges): an ordinary account is enough. `UI:N` (no user interaction). `AC:L` (low attack complexity): no race. `C:L` (partial confidentiality impact): the lock file (holder metadata) and the lock database are readable where `0o600` was meant to keep them private. `I:L` (partial integrity impact): in the directory layout the maintainers tested, the other account can also write both files, which lets it corrupt the lock's own state but nothing the lock protects. `A:L` (partial availability impact): the other account can hold the byte-range lock and make the owner wait or time out. `S:U` (scope unchanged). Classification from the review: **Windows permission failure with security impact only where callers rely on `mode=0o600` across accounts**. The review had marked it an unconfirmed Windows claim, since the scanner traced stand-in Win32 calls on Linux. The maintainers have since confirmed it on Windows with two local accounts (see Evidence). The scanner rated this medium; the maintainers keep medium. ## Scope and preconditions - The affected classes are `FileLock` and `AsyncFileLock` on Windows (`WindowsFileLock`), and the SQLite database of `ReadWriteLock` and `AsyncReadWriteLock`. Both go through `_open_non_reparse_fd`. The soft locks create their markers with `os.open`, which also keeps only a read-only bit of the mode on Windows; the scanner did not examine them further. - The directory is one that other local accounts cannot write, which the documentation already requires on Windows, but whose inheritable entries grant them read (or modify) access to new files. Examples are a service's data directory readable by `Users`, or any directory with `(OI)(CI)` entries (entries that new files and sub-directories inherit) for another account. A directory whose ACL already excludes other accounts, such as one inside a user profile, hides the problem. - The other account must open the file. According to the `LockFileEx` documentation, read access is enough to take the byte-range lock, so it can hold the lock whenever the owner does not. The lock file exists while the owner holds the lock, and stays after release with `preserve_lock_file=True`. The `ReadWriteLock` database is not unlinked at any point. - Unix is not affected, because `UnixFileLock` creates the file with the mode and repeats it with `fchmod`. Mutual exclusion between cooperating processes is not affected. ## Affected code Scanned commit `b831496b0273`: [`_open_non_reparse_fd` reduces the mode to one `read_only` bit](https://github.com/tox-dev/filelock/blob/b831496b0273ecd11bf02b8d080ca8b673a538c1/src/filelock/_windows.py#L252-L253). That bit is false for every accepted mode, because [`_check_mode`](https://github.com/tox-dev/filelock/blob/b831496b0273ecd11bf02b8d080ca8b673a538c1/src/filelock/_api.py#L526) rejects any mode without owner read and write, and an unset mode becomes `0o666`. In [`_nt_open`](https://github.com/tox-dev/filelock/blob/b831496b0273ecd11bf02b8d080ca8b673a538c1/src/filelock/_windows.py#L283-L310) the `OBJECT_ATTRIBUTES.SecurityDescriptor` field stays unassigned, and `read_only` only chooses `FILE_ATTRIBUTE_READONLY`. [`_open_lock_database`](https://github.com/tox-dev/filelock/blob/b831496b0273ecd11bf02b8d080ca8b673a538c1/src/filelock/_read_write.py#L1079-L1086) passes `0o600` through the same function on Windows. ## Introduced [d0061e4](https://github.com/tox-dev/filelock/commit/d0061e4