Commit ccad85d
authored
![renovate-coop-norge[bot]](https://avatars.githubusercontent.com/in/635546?v=4&size=40){kind=avatar}
chore(deps): update dependency filelock to v3.29.5 [security] (#4091)
This PR contains the following updates:
| Package | Change |
[Age](https://docs.renovatebot.com/merge-confidence/) |
[Confidence](https://docs.renovatebot.com/merge-confidence/) |
|---|---|---|---|
| [filelock](https://redirect.github.com/tox-dev/py-filelock) | `3.29.4`
→ `3.29.5` |
|
|
---
### filelock has a TOCTOU race condition which allows symlink attacks
during lock file creation
[CVE-2025-68146](https://nvd.nist.gov/vuln/detail/CVE-2025-68146) /
[GHSA-w853-jp5j-5j7f](https://redirect.github.com/advisories/GHSA-w853-jp5j-5j7f)
<details>
<summary>More information</summary>
#### Details
##### Impact
A Time-of-Check-Time-of-Use (TOCTOU) race condition allows local
attackers to corrupt or truncate arbitrary user files through symlink
attacks. The vulnerability exists in both Unix and Windows lock file
creation where filelock checks if a file exists before opening it with
O_TRUNC. An attacker can create a symlink pointing to a victim file in
the time gap between the check and open, causing os.open() to follow the
symlink and truncate the target file.
**Who is impacted:**
All users of filelock on Unix, Linux, macOS, and Windows systems. The
vulnerability cascades to dependent libraries:
- **virtualenv users**: Configuration files can be overwritten with
virtualenv metadata, leaking sensitive paths
- **PyTorch users**: CPU ISA cache or model checkpoints can be
corrupted, causing crashes or ML pipeline failures
- **poetry/tox users**: through using virtualenv or filelock on their
own.
Attack requires local filesystem access and ability to create symlinks
(standard user permissions on Unix; Developer Mode on Windows 10+).
Exploitation succeeds within 1-3 attempts when lock file paths are
predictable.
##### Patches
Fixed in version **3.20.1**.
**Unix/Linux/macOS fix:** Added O_NOFOLLOW flag to os.open() in
UnixFileLock.\_acquire() to prevent symlink following.
**Windows fix:** Added GetFileAttributesW API check to detect reparse
points (symlinks/junctions) before opening files in
WindowsFileLock.\_acquire().
**Users should upgrade to filelock 3.20.1 or later immediately.**
##### Workarounds
If immediate upgrade is not possible:
1. Use SoftFileLock instead of UnixFileLock/WindowsFileLock (note:
different locking semantics, may not be suitable for all use cases)
2. Ensure lock file directories have restrictive permissions (chmod
0700) to prevent untrusted users from creating symlinks
3. Monitor lock file directories for suspicious symlinks before running
trusted applications
**Warning:** These workarounds provide only partial mitigation. The race
condition remains exploitable. Upgrading to version 3.20.1 is strongly
recommended.
______________________________________________________________________
##### Technical Details: How the Exploit Works
##### The Vulnerable Code Pattern
**Unix/Linux/macOS** (`src/filelock/_unix.py:39-44`):
```python
def _acquire(self) -> None:
ensure_directory_exists(self.lock_file)
open_flags = os.O_RDWR | os.O_TRUNC # (1) Prepare to truncate
if not Path(self.lock_file).exists(): # (2) CHECK: Does file exist?
open_flags |= os.O_CREAT
fd = os.open(self.lock_file, open_flags, ...) # (3) USE: Open and truncate
```
**Windows** (`src/filelock/_windows.py:19-28`):
```python
def _acquire(self) -> None:
raise_on_not_writable_file(self.lock_file) # (1) Check writability
ensure_directory_exists(self.lock_file)
flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC # (2) Prepare to truncate
fd = os.open(self.lock_file, flags, ...) # (3) Open and truncate
```
##### The Race Window
The vulnerability exists in the gap between operations:
**Unix variant:**
```
Time Victim Thread Attacker Thread
---- ------------- ---------------
T0 Check: lock_file exists? → False
T1 ↓ RACE WINDOW
T2 Create symlink: lock → victim_file
T3 Open lock_file with O_TRUNC
→ Follows symlink
→ Opens victim_file
→ Truncates victim_file to 0 bytes! ☠️
```
**Windows variant:**
```
Time Victim Thread Attacker Thread
---- ------------- ---------------
T0 Check: lock_file writable?
T1 ↓ RACE WINDOW
T2 Create symlink: lock → victim_file
T3 Open lock_file with O_TRUNC
→ Follows symlink/junction
→ Opens victim_file
→ Truncates victim_file to 0 bytes! ☠️
```
##### Step-by-Step Attack Flow
**1. Attacker Setup:**
```python
##### Attacker identifies target application using filelock
lock_path = "/tmp/myapp.lock" # Predictable lock path
victim_file = "/home/victim/.ssh/config" # High-value target
```
**2. Attacker Creates Race Condition:**
```python
import os
import threading
def attacker_thread():
# Remove any existing lock file
try:
os.unlink(lock_path)
except FileNotFoundError:
pass
# Create symlink pointing to victim file
os.symlink(victim_file, lock_path)
print(f"[Attacker] Created: {lock_path} → {victim_file}")
##### Launch attack
threading.Thread(target=attacker_thread).start()
```
**3. Victim Application Runs:**
```python
from filelock import UnixFileLock
##### Normal application code
lock = UnixFileLock("/tmp/myapp.lock")
lock.acquire() # ← VULNERABILITY TRIGGERED HERE
##### At this point, /home/victim/.ssh/config is now 0 bytes!
```
**4. What Happens Inside os.open():**
On Unix systems, when `os.open()` is called:
```c
// Linux kernel behavior (simplified)
int open(const char *pathname, int flags) {
struct file *f = path_lookup(pathname); // Resolves symlinks by default!
if (flags & O_TRUNC) {
truncate_file(f); // ← Truncates the TARGET of the symlink
}
return file_descriptor;
}
```
Without `O_NOFOLLOW` flag, the kernel follows the symlink and truncates
the target file.
##### Why the Attack Succeeds Reliably
**Timing Characteristics:**
- **Check operation** (Path.exists()): ~100-500 nanoseconds
- **Symlink creation** (os.symlink()): ~1-10 microseconds
- **Race window**: ~1-5 microseconds (very small but exploitable)
- **Thread scheduling quantum**: ~1-10 milliseconds
**Success factors:**
1. **Tight loop**: Running attack in a loop hits the race window within
1-3 attempts
2. **CPU scheduling**: Modern OS thread schedulers frequently
context-switch during I/O operations
3. **No synchronization**: No atomic file creation prevents the race
4. **Symlink speed**: Creating symlinks is extremely fast (metadata-only
operation)
##### Real-World Attack Scenarios
**Scenario 1: virtualenv Exploitation**
```python
##### Victim runs: python -m venv /tmp/myenv
##### Attacker racing to create:
os.symlink("/home/victim/.bashrc", "/tmp/myenv/pyvenv.cfg")
##### Result: /home/victim/.bashrc overwritten with:
##### home = /usr/bin/python3
##### include-system-site-packages = false
##### version = 3.11.2
##### ← Original .bashrc contents LOST + virtualenv metadata LEAKED to attacker
```
**Scenario 2: PyTorch Cache Poisoning**
```python
##### Victim runs: import torch
##### PyTorch checks CPU capabilities, uses filelock on cache
##### Attacker racing to create:
os.symlink("/home/victim/.torch/compiled_model.pt", "/home/victim/.cache/torch/cpu_isa_check.lock")
##### Result: Trained ML model checkpoint truncated to 0 bytes
##### Impact: Weeks of training lost, ML pipeline DoS
```
##### Why Standard Defenses Don't Help
**File permissions don't prevent this:**
- Attacker doesn't need write access to victim_file
- os.open() with O_TRUNC follows symlinks using the *victim's*
permissions
- The victim process truncates its own file
**Directory permissions help but aren't always feasible:**
- Lock files often created in shared /tmp directory (mode 1777)
- Applications may not control lock file location
- Many apps use predictable paths in user-writable directories
**File locking doesn't prevent this:**
- The truncation happens *during* the open() call, before any lock is
acquired
- fcntl.flock() only prevents concurrent lock acquisition, not symlink
attacks
##### Exploitation Proof-of-Concept Results
From empirical testing with the provided PoCs:
**Simple Direct Attack** (`filelock_simple_poc.py`):
- Success rate: 33% per attempt (1 in 3 tries)
- Average attempts to success: 2.1
- Target file reduced to 0 bytes in \<100ms
**virtualenv Attack** (`weaponized_virtualenv.py`):
- Success rate: ~90% on first attempt (deterministic timing)
- Information leaked: File paths, Python version, system configuration
- Data corruption: Complete loss of original file contents
**PyTorch Attack** (`weaponized_pytorch.py`):
- Success rate: 25-40% per attempt
- Impact: Application crashes, model loading failures
- Recovery: Requires cache rebuild or model retraining
**Discovered and reported by:** George Tsigourakos
(@​tsigouris007)
#### Severity
- CVSS Score: 6.3 / 10 (Medium)
- Vector String: `CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:H/A:H`
#### References
-
[https://github.com/tox-dev/filelock/security/advisories/GHSA-w853-jp5j-5j7f](https://redirect.github.com/tox-dev/filelock/security/advisories/GHSA-w853-jp5j-5j7f)
-
[https://github.com/tox-dev/filelock/commit/4724d7f8c3393ec1f048c93933e6e3e6ec321f0e](https://redirect.github.com/tox-dev/filelock/commit/4724d7f8c3393ec1f048c93933e6e3e6ec321f0e)
-
[https://github.com/tox-dev/filelock](https://redirect.github.com/tox-dev/filelock)
-
[https://github.com/tox-dev/filelock/releases/tag/3.20.1](https://redirect.github.com/tox-dev/filelock/releases/tag/3.20.1)
-
[https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants](https://learn.microsoft.com/en-us/windows/win32/fileio/file-attribute-constants)
-
[https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html](https://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html)
This data is provided by
[OSV](https://osv.dev/vulnerability/GHSA-w853-jp5j-5j7f) and the [GitHub
Advisory Database](https://redirect.github.com/github/advisory-database)
([CC-BY
4.0](https://redirect.github.com/github/advisory-database/blob/main/LICENSE.md)).
</details>
---
### filelock Time-of-Check-Time-of-Use (TOCTOU) Symlink Vulnerability in
SoftFileLock
[CVE-2026-22701](https://nvd.nist.gov/vuln/detail/CVE-2026-22701) /
[GHSA-qmgc-5h2g-mvrw](https://redirect.github.com/advisories/GHSA-qmgc-5h2g-mvrw)
<details>
<summary>More information</summary>
#### Details
##### Vulnerability Summary
**Title:** Time-of-Check-Time-of-Use (TOCTOU) Symlink Vulnerability in
SoftFileLock
**Affected Component:** `filelock` package - `SoftFileLock` class
**File:** `src/filelock/_soft.py` lines 17-27
**CWE:** CWE-362, CWE-367, CWE-59
---
##### Description
A TOCTOU race condition vulnerability exists in the `SoftFileLock`
implementation of the filelock package. An attacker with local
filesystem access and permission to create symlinks can exploit a race
condition between the permission validation and file creation to cause
lock operations to fail or behave unexpectedly.
The vulnerability occurs in the `_acquire()` method between
`raise_on_not_writable_file()` (permission check) and `os.open()` (file
creation). During this race window, an attacker can create a symlink at
the lock file path, potentially causing the lock to operate on an
unintended target file or leading to denial of service.
##### Attack Scenario
```
1. Lock attempts to acquire on /tmp/app.lock
2. Permission validation passes
3. [RACE WINDOW] - Attacker creates: ln -s /tmp/important.txt /tmp/app.lock
4. os.open() tries to create lock file
5. Lock operates on attacker-controlled target file or fails
```
---
##### Impact
_What kind of vulnerability is it? Who is impacted?_
This is a **Time-of-Check-Time-of-Use (TOCTOU) race condition
vulnerability** affecting any application using `SoftFileLock` for
inter-process synchronization.
**Affected Users:**
- Applications using `filelock.SoftFileLock` directly
- Applications using the fallback `FileLock` on systems without `fcntl`
support (e.g., GraalPy)
**Consequences:**
- **Silent lock acquisition failure** - applications may not detect that
exclusive resource access is not guaranteed
- **Denial of Service** - attacker can prevent lock file creation by
maintaining symlink
- **Resource serialization failures** - multiple processes may acquire
"locks" simultaneously
- **Unintended file operations** - lock could operate on
attacker-controlled files
**CVSS v4.0 Score:** 5.6 (Medium)
**Vector:** CVSS:4.0/AV:L/AT:L/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
**Attack Requirements:**
- Local filesystem access to the directory containing lock files
- Permission to create symlinks (standard for regular unprivileged users
on Unix/Linux)
- Ability to time the symlink creation during the narrow race window
---
##### Patches
_Has the problem been patched? What versions should users upgrade to?_
Yes, the vulnerability has been patched by adding the `O_NOFOLLOW` flag
to prevent symlink following during lock file creation.
**Patched Version:** Next release (commit:
255ed068bc85d1ef406e50a135e1459170dd1bf0)
**Mitigation Details:**
- The `O_NOFOLLOW` flag is added conditionally and gracefully degrades
on platforms without support
- On platforms with `O_NOFOLLOW` support (most modern systems): symlink
attacks are completely prevented
- On platforms without `O_NOFOLLOW` (e.g., GraalPy): TOCTOU window
remains but is documented
**Users should:**
- Upgrade to the patched version when available
- For critical deployments, consider using `UnixFileLock` or
`WindowsFileLock` instead of the fallback `SoftFileLock`
---
##### Workarounds
_Is there a way for users to fix or remediate the vulnerability without
upgrading?_
For users unable to update immediately:
1. **Avoid `SoftFileLock` in security-sensitive contexts** - use
`UnixFileLock` or `WindowsFileLock` when available (these were already
patched for CVE-2025-68146)
2. **Restrict filesystem permissions** - prevent untrusted users from
creating symlinks in lock file directories:
```bash
chmod 700 /path/to/lock/directory
```
3. **Use process isolation** - isolate untrusted code from lock file
paths to prevent symlink creation
4. **Monitor lock operations** - implement application-level checks to
verify lock acquisitions are successful before proceeding with critical
operations
---
##### References
_Are there any links users can visit to find out more?_
- **Similar Vulnerability:** CVE-2025-68146 (TOCTOU vulnerability in
UnixFileLock/WindowsFileLock)
- **CWE-362 (Concurrent Execution using Shared Resource):**
https://cwe.mitre.org/data/definitions/362.html
- **CWE-367 (Time-of-check Time-of-use Race Condition):**
https://cwe.mitre.org/data/definitions/367.html
- **CWE-59 (Improper Link Resolution Before File Access):**
https://cwe.mitre.org/data/definitions/59.html
- **O_NOFOLLOW documentation:**
https://man7.org/linux/man-pages/man2/open.2.html
- **GitHub Repository:** https://github.com/tox-dev/filelock
---
**Reported by:** George Tsigourakos (@​tsigouris007)
#### Severity
- CVSS Score: 5.3 / 10 (Medium)
- Vector String: `CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H`
#### References
-
[https://github.com/tox-dev/filelock/security/advisories/GHSA-qmgc-5h2g-mvrw](https://redirect.github.com/tox-dev/filelock/security/advisories/GHSA-qmgc-5h2g-mvrw)
-
[https://nvd.nist.gov/vuln/detail/CVE-2026-22701](https://nvd.nist.gov/vuln/detail/CVE-2026-22701)
-
[https://github.com/tox-dev/filelock/commit/255ed068bc85d1ef406e50a135e1459170dd1bf0](https://redirect.github.com/tox-dev/filelock/commit/255ed068bc85d1ef406e50a135e1459170dd1bf0)
-
[https://github.com/tox-dev/filelock/commit/41b42dd2c72aecf7da83dbda5903b8087dddc4d5](https://redirect.github.com/tox-dev/filelock/commit/41b42dd2c72aecf7da83dbda5903b8087dddc4d5)
-
[https://github.com/tox-dev/filelock](https://redirect.github.com/tox-dev/filelock)
This data is provided by
[OSV](https://osv.dev/vulnerability/GHSA-qmgc-5h2g-mvrw) and the [GitHub
Advisory Database](https://redirect.github.com/github/advisory-database)
([CC-BY
4.0](https://redirect.github.com/github/advisory-database/blob/main/LICENSE.md)).
</details>
---
### Release Notes
<details>
<summary>tox-dev/py-filelock (filelock)</summary>
###
[`v3.29.5`](https://redirect.github.com/tox-dev/filelock/releases/tag/3.29.5)
[Compare
Source](https://redirect.github.com/tox-dev/py-filelock/compare/3.29.4...3.29.5)
<!-- Release notes generated using configuration in .github/release.yaml
at main -->
#### What's Changed
- serialise read/write release rollback against a concurrent acquire by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#563](https://redirect.github.com/tox-dev/filelock/pull/563)
- 🔒 fix(soft\_rw): refresh held marker through the verified fd by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#565](https://redirect.github.com/tox-dev/filelock/pull/565)
- only unlink the writer marker on release if it is still ours by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#566](https://redirect.github.com/tox-dev/filelock/pull/566)
- don't follow symlinks in raise\_on\_not\_writable\_file by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#567](https://redirect.github.com/tox-dev/filelock/pull/567)
- don't complete a writer acquire on a peer's reclaimed marker by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#571](https://redirect.github.com/tox-dev/filelock/pull/571)
- use a private break name in break\_lock\_file by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#576](https://redirect.github.com/tox-dev/filelock/pull/576)
- Keep Unix lock files after release by
[@​itscloud0](https://redirect.github.com/itscloud0) in
[tox-dev/filelock#577](https://redirect.github.com/tox-dev/filelock/pull/577)
- test: fix Windows type check broken by
[#​577](https://redirect.github.com/tox-dev/py-filelock/issues/577)
by [@​gaborbernat](https://redirect.github.com/gaborbernat) in
[tox-dev/filelock#580](https://redirect.github.com/tox-dev/filelock/pull/580)
- roll back a read acquire's open transaction when its SELECT fails by
[@​dxbjavid](https://redirect.github.com/dxbjavid) in
[tox-dev/filelock#575](https://redirect.github.com/tox-dev/filelock/pull/575)
- lifetime: reject negative, non-numeric, and bool values at the setter
by [@​HrachShah](https://redirect.github.com/HrachShah) in
[tox-dev/filelock#573](https://redirect.github.com/tox-dev/filelock/pull/573)
#### New Contributors
- [@​itscloud0](https://redirect.github.com/itscloud0) made their
first contribution in
[tox-dev/filelock#577](https://redirect.github.com/tox-dev/filelock/pull/577)
- [@​HrachShah](https://redirect.github.com/HrachShah) made their
first contribution in
[tox-dev/filelock#573](https://redirect.github.com/tox-dev/filelock/pull/573)
**Full Changelog**:
<tox-dev/filelock@3.29.4...3.29.5>
</details>
---
### Configuration
📅 **Schedule**: (UTC)
- Branch creation
- At any time (no schedule defined)
- Automerge
- At any time (no schedule defined)
🚦 **Automerge**: Enabled.
♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.
🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.
---
- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box
---
This PR has been generated by [Mend
Renovate](https://redirect.github.com/renovatebot/renovate).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0My4yMjQuMSIsInVwZGF0ZWRJblZlciI6IjQzLjIyNC4xIiwidGFyZ2V0QnJhbmNoIjoibWFpbiIsImxhYmVscyI6WyJkZXBlbmRlbmNpZXMiLCJmaWxlbG9jayIsInJlbm92YXRlIl19-->
Co-authored-by: renovate-coop-norge[bot] <151545514+renovate-coop-norge[bot]@users.noreply.github.com>1 parent 5881640 commit ccad85d
1 file changed
Lines changed: 3 additions & 3 deletions
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
425 | 425 | | |
426 | 426 | | |
427 | 427 | | |
428 | | - | |
429 | | - | |
430 | | - | |
| 428 | + | |
| 429 | + | |
| 430 | + | |
431 | 431 | | |
432 | 432 | | |
433 | 433 | | |
| |||
0 commit comments