{"id":"CVE-2026-112910","kind":"vulnerability","aliases":["CVE-2026-112910","GHSA-8mx5-7m5m-r77g"],"related":[],"title":"filelock: WindowsFileLock ignores mode: a 0o600 lock file and the ReadWriteLock database inherit the directory ACL","description":"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.\n\n`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.\n\nAnthropic's OSS Scanner reported this in private. Finding covered by this advisory:\n\n- `ANT-2026-0KEO0DDO` [medium, CWE-732]: WindowsFileLock ignores mode; 0o600 lock files inherit the directory ACL.\n\n## Severity\n\n**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).**\n\n`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).\n\nClassification 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.\n\n## Scope and preconditions\n\n- 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.\n- 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.\n- 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.\n- 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.\n\n## Affected code\n\nScanned 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.\n\n## Introduced\n\n[d0061e4](https://github.com/tox-dev/filelock/commit/d0061e4643df) \"added multiuser support and associated tests\" ([#192](https://github.com/tox-dev/filelock/pull/192), 2023-03-15), first tag 3.10.0 (verified), added the `mode` parameter and on Windows handed it to `os.open`, which applies only the read-only attribute. The Windows backend has applied no more of the mode than that at any version, so this is a long-standing gap rather than a regression.\n\n## Mechanism\n\n`_open_non_reparse_fd(path, mode)` computes `read_only = not mode & _OWNER_WRITE` and calls `_nt_open(path, read_only=read_only)`. `_nt_open` fills an `OBJECT_ATTRIBUTES` with the NT path and `OBJ_CASE_INSENSITIVE` and leaves `SecurityDescriptor` NULL. It then calls `NtCreateFile` with `FILE_OPEN_IF` and `FILE_ATTRIBUTE_NORMAL` (or `FILE_ATTRIBUTE_READONLY` when `read_only`, which no accepted mode produces). Nothing consults the group and other bits. Per the `NtCreateFile` and `OBJECT_ATTRIBUTES` documentation, a NULL descriptor gives the new file default security, which on NTFS is the set of inheritable entries of the parent directory. A lock file created with `mode=0o600` in a directory that hands down read access to `Users` is therefore readable by `Users`.\n\nNothing tells the caller. The constructor validates the mode, `lock.mode` returns `0o600`, and `has_explicit_mode` is `True`. `docs/concepts.rst` says \"filelock creates the file with it\" and that \"`0o600` and `0o700` keep other UIDs out\", with no Windows caveat. Only the `_open_non_reparse_fd` docstring and a comment in `_soft.py` record the limitation.\n\n## Reproduction\n\nThe scanner's reproducer for `ANT-2026-0KEO0DDO`, quoted as received. It ran against commit `b831496b0273`.\n\n**`repro`**\n\n```python\n#!/usr/bin/env python3\nimport os\nimport shutil\nimport subprocess\nimport sys\nimport tempfile\n\nprivate_job = \"/tmp/repro.d/job_with_private_lock.py\"  # with FileLock(path, mode=0o600)\ndefault_job = \"/tmp/repro.d/job_with_default_lock.py\"  # with FileLock(path)\non_windows_backend = \"/tmp/repro.d/run_on_windows_backend.py\"  # prints every Win32 call filelock makes\n\nos.umask(0o022)\nlocks = tempfile.mkdtemp()\n\n# control: UnixFileLock, which leaves the lock file behind\nsubprocess.run([sys.executable, private_job, f\"{locks}/private.lock\"], check=True)\nsubprocess.run([sys.executable, default_job, f\"{locks}/default.lock\"], check=True)\nunix_private_mode = os.stat(f\"{locks}/private.lock\").st_mode & 0o777\nunix_default_mode = os.stat(f\"{locks}/default.lock\").st_mode & 0o777\n\n# trigger: the same two programs on WindowsFileLock, same lock name so the call lists can be compared whole\nwindows_private = [sys.executable, on_windows_backend, private_job, f\"{locks}/job.lock\"]\nwindows_default = [sys.executable, on_windows_backend, default_job, f\"{locks}/job.lock\"]\nwindows_private_calls = subprocess.run(windows_private, check=True, capture_output=True, text=True).stdout.splitlines()\nwindows_default_calls = subprocess.run(windows_default, check=True, capture_output=True, text=True).stdout.splitlines()\nshutil.rmtree(locks)\n\n# check: mode=0o600 must reach the OS; on Windows that means a security descriptor on NtCreateFile\nprint(f\"CONTROL  UnixFileLock FileLock(path, mode=0o600): lock file mode {unix_private_mode:#o}\")\nprint(f\"CONTROL  UnixFileLock FileLock(path):             lock file mode {unix_default_mode:#o}\")\nfor call in windows_private_calls:\n    print(f\"OBSERVED WindowsFileLock FileLock(path, mode=0o600): {call}\")\nfor call in windows_default_calls:\n    print(f\"OBSERVED WindowsFileLock FileLock(path):             {call}\")\nprint(f\"OBSERVED the two Win32 call lists are identical: {windows_private_calls == windows_default_calls}\")\n\nhonoured_on_unix = unix_private_mode == 0o600 and unix_default_mode == 0o644\nprivate_create = next(call for call in windows_private_calls if call.startswith(\"NtCreateFile(\"))\ndropped_on_windows = (\n    \"ObjectAttributes.SecurityDescriptor=None\" in private_create\n    and windows_private_calls == windows_default_calls\n)\nprint(\"BUG\" if honoured_on_unix and dropped_on_windows else \"OK\")\n```\n\n**`repro.d/job_with_default_lock.py`**\n\n```python\nimport sys\n\nfrom filelock import FileLock\n\nwith FileLock(sys.argv[1]):\n    pass\n```\n\n**`repro.d/job_with_private_lock.py`**\n\n```python\nimport sys\n\nfrom filelock import FileLock\n\nwith FileLock(sys.argv[1], mode=0o600):\n    pass\n```\n\n**`repro.d/run_on_windows_backend.py`**\n\n```python\nimport ctypes\nimport fcntl\nimport os\nimport runpy\nimport sys\nimport types\n\n# Stand-ins for the ntdll, kernel32 and msvcrt functions filelock's Windows backend calls. Each prints the call with\n# the arguments filelock passed, then does the nearest Linux thing so the program runs to its end.\n\n\ndef RtlDosPathNameToNtPathName_U_WithStatus(dos_path, nt_name, _file_part, _relative_name):\n    print(f\"RtlDosPathNameToNtPathName_U_WithStatus({os.path.basename(dos_path)!r})\")\n    nt_name._obj.Buffer = os.path.abspath(dos_path)\n    return 0  # STATUS_SUCCESS\n\n\ndef NtCreateFile(\n    handle, access, attributes, _io_status, allocation_size, file_attributes, share, disposition, options, ea, ea_length\n):\n    object_attributes = attributes._obj\n    print(\n        f\"NtCreateFile(DesiredAccess={access:#x},\"\n        f\" ObjectAttributes.Attributes={object_attributes.Attributes:#x},\"\n        f\" ObjectAttributes.SecurityDescriptor={object_attributes.SecurityDescriptor},\"\n        f\" AllocationSize={allocation_size}, FileAttributes={file_attributes:#x}, ShareAccess={share:#x},\"\n        f\" CreateDisposition={disposition}, CreateOptions={options:#x}, EaBuffer={ea}, EaLength={ea_length})\"\n    )\n    path = object_attributes.ObjectName.contents.Buffer\n    handle._obj.value = os.open(path, os.O_RDWR | os.O_CREAT | os.O_NOFOLLOW)\n    return 0  # STATUS_SUCCESS\n\n\ndef RtlFreeUnicodeString(_nt_name):\n    print(\"RtlFreeUnicodeString()\")\n\n\ndef GetFileInformationByHandle(_handle, info):\n    print(\"GetFileInformationByHandle()\")\n    info._obj.dwFileAttributes = 0x80  # FILE_ATTRIBUTE_NORMAL: not a reparse point\n    return True\n\n\ndef LockFileEx(handle, flags, _reserved, bytes_low, bytes_high, _overlapped):\n    print(f\"LockFileEx(dwFlags={flags:#x}, nNumberOfBytesToLockLow={bytes_low}, nNumberOfBytesToLockHigh={bytes_high})\")\n    fcntl.flock(handle, fcntl.LOCK_EX)\n    return True\n\n\ndef UnlockFileEx(handle, _reserved, bytes_low, bytes_high, _overlapped):\n    print(f\"UnlockFileEx(nNumberOfBytesToUnlockLow={bytes_low}, nNumberOfBytesToUnlockHigh={bytes_high})\")\n    fcntl.flock(handle, fcntl.LOCK_UN)\n    return True\n\n\n# only a filelock that builds a security descriptor for the lock file calls this\ndef ConvertStringSecurityDescriptorToSecurityDescriptorW(sddl, _revision, descriptor, _size):\n    print(f\"ConvertStringSecurityDescriptorToSecurityDescriptorW({sddl!r})\")\n    descriptor._obj.value = 1  # any address but NULL\n    return True\n\n\n# filelock sets argtypes on these at import; a lock taken without contention never calls them\ndef not_called(*_arguments):\n    raise NotImplementedError\n\n\ndlls = {\n    \"ntdll\": types.SimpleNamespace(\n        RtlDosPathNameToNtPathName_U_WithStatus=RtlDosPathNameToNtPathName_U_WithStatus,\n        NtCreateFile=NtCreateFile,\n        RtlFreeUnicodeString=RtlFreeUnicodeString,\n        RtlNtStatusToDosError=not_called,\n    ),\n    \"kernel32\": types.SimpleNamespace(\n        GetFileInformationByHandle=GetFileInformationByHandle,\n        LockFileEx=LockFileEx,\n        UnlockFileEx=UnlockFileEx,\n        CloseHandle=not_called,\n        OpenProcess=not_called,\n        GetProcessTimes=not_called,\n    ),\n    \"advapi32\": types.SimpleNamespace(\n        ConvertStringSecurityDescriptorToSecurityDescriptorW=ConvertStringSecurityDescriptorToSecurityDescriptorW,\n    ),\n}\n\n# Import filelock once on the real platform, so the standard library modules it uses load their Linux versions, then\n# drop it and import it again with the Windows branches active. A HANDLE is the Linux descriptor number.\nimport filelock  # noqa: E402\n\nfor name in [name for name in sys.modules if name.split(\".\")[0] == \"filelock\"]:\n    del sys.modules[name]\n\nctypes.WinDLL = lambda name, use_last_error=False: dlls[name]\nsys.modules[\"msvcrt\"] = types.SimpleNamespace(open_osfhandle=lambda handle, _flags: handle, get_osfhandle=lambda fd: fd)\nos.O_NOINHERIT = 0\nsys.platform = \"win32\"\n\nimport filelock  # noqa: E402, F811\n\nassert filelock.FileLock is filelock.WindowsFileLock\n\nsys.argv = sys.argv[1:]\nrunpy.run_path(sys.argv[0], run_name=\"__main__\")\n```\n\n## Failure sequence\n\n```mermaid\nsequenceDiagram\n    participant O as owner process: FileLock(path, mode=0o600)\n    participant N as NtCreateFile\n    participant F as lock file (inherits the directory ACL)\n    participant U as other local account\n    O->>N: _open_non_reparse_fd(path, 0o600): read_only=False, SecurityDescriptor=NULL\n    rect rgb(255, 214, 214)\n        N-->>F: created with the parent's inheritable entries only, group and other bits not consulted\n        Note over F: the file reports mode 0o600 to the owner, the ACL says otherwise\n    end\n    O->>F: LockFileEx (holds the lock), release, unlock\n    U->>F: open for read (and write, where the directory hands down modify)\n    U->>F: LockFileEx through that handle\n    O->>F: acquire() -> waits or Timeout while U holds the byte-range lock\n    U->>F: read holder metadata left by on_acquired with preserve_lock_file=True\n```\n\n## Evidence\n\nThe scanner's reproducer runs on a Linux image. It imports filelock's unmodified Windows backend with `sys.platform == \"win32\"` over stand-ins that print every Win32 call. The program with `mode=0o600` and the one without produce identical call lists (`RtlDosPathNameToNtPathName_U_WithStatus`, `NtCreateFile` with `FileAttributes=0x80` and `ObjectAttributes.SecurityDescriptor=None`, `RtlFreeUnicodeString`, `GetFileInformationByHandle`, `LockFileEx`, `UnlockFileEx`), while the Unix control produced `0o600` and `0o644` files. It prints `OBSERVED the two Win32 call lists are identical: True` and `BUG`. The scanner stated that it inferred the resulting ACL, and what another user can then do, from the documentation and did not run on Windows.\n\nMaintainer triage: the stand-in reproducer prints `BUG` on the scanned commit `b831496` and on the 4.2.0 release image.\n\nMaintainer verification on Windows 11 with two local accounts: a script creates `private.lock` with `FileLock(mode=0o600, preserve_lock_file=True)`, `default.lock` without a mode, and a `ReadWriteLock` database `lock.db` as the first account, in a directory granted `(OI)(CI)(M)` to a second account that is a member of `Users`. It then opens each file under the second account's logon token with `LogonUserW` and `ImpersonateLoggedOnUser`. On 4.2.0 the second account could open `private.lock` and `lock.db` for both read and write, the same as `default.lock`, and `icacls` listed only inherited `(I)` entries on all three. This confirms the claim the review had marked unconfirmed.\n\n## Impact\n\nA program that passes `mode=0o600` so that other accounts cannot open its lock file gets no such restriction on Windows. In a directory that hands down read access, another account can hold the lock and make the owner wait or time out, and read holder metadata in a preserved lock file. Where the directory hands down modify access, as in the maintainers' test, it can also write the lock file and the `ReadWriteLock` database. With the mode honoured, as on Unix, a user without write access to the directory can do none of this. The exposure ends there: the effect reaches only the lock file or lock database, and mutual exclusion between processes that follow the protocol still holds.\n\n## Workarounds\n\n- On Windows, keep lock files and `ReadWriteLock` databases in a directory whose ACL already excludes other accounts (inside the user profile, or a directory with inheritance disabled and only the owner, `SYSTEM` and `Administrators` granted), rather than relying on `mode`.\n- After creating a lock file with `preserve_lock_file=True` or a `ReadWriteLock` database, set its ACL yourself, for example `icacls <file> /inheritance:r /grant:r \"<owner>:F\" \"SYSTEM:F\" \"Administrators:F\"`; a file that exists keeps its ACL on later opens.\n- Do not store anything confidential in the lock file through `on_acquired` on Windows.\n\n## Patched version\n\n4.2.1.\n\nFix: https://github.com/tox-dev/filelock/pull/835\n\n## Credits\n\nReported by Anthropic's OSS Scanner (automated analysis), 15 October 2026; reviewed by the maintainers.\n\n- 2026-10-15 23:08 UTC: report received (36 findings; this one rated medium by the scanner)\n- 2026-10-16 05:38 UTC: draft advisory created (first as part of GHSA-69hj-f68j-2879, then split out); two-account verification on Windows by the maintainers\n- 2026-10-16 01:16 UTC: fix PR #835 opened","summary":"On Windows, filelock ignores the mode argument, so a lock file or ReadWriteLock database created with mode=0o600 gets the parent directory's inherited permissions. Other local accounts that can read or write that directory can open the file, hold the byte-range lock to block the owner, or read holder metadata.","severity":"medium","cvss":5.3,"epss":null,"exploited":false,"exploited_at":null,"products":[{"name":"filelock","fixed":["4.2.1"],"affected":">= 3.10.0, <= 4.2.0","ecosystem":"pypi"}],"ecosystems":["pypi"],"tags":["cwe-732","filelock","package","python","windows"],"not_affected_if":["directory-excludes-other-accounts","single-user-host","unix-only"],"how_to_check":"- Run `pip show filelock` on Windows hosts and check whether the version is between `3.10.0` and `4.2.0`.\n- Search code for `FileLock(` or `ReadWriteLock(` calls that pass `mode=0o600`, and check whether their lock directory grants other local accounts access to new files (inheritable ACL entries, `(OI)(CI)`).","fix":"- Upgrade `filelock` to `4.2.1`.\n- Until upgraded, keep lock files in a directory that other local accounts cannot read or write, such as a directory inside a user profile.","status":"open","published_at":"2026-10-28T21:08:55+00:00","first_seen_at":"2026-10-28T21:12:45+00:00","triaged_at":"2026-10-28T21:13:41+00:00","updated_at":"2026-10-28T21:13:41+00:00","category":"package","confidence":0.8,"triage":{"at":"2026-10-28T21:13:41Z","model":"claude-haiku-5-5","output":{"fix":"- Upgrade `filelock` to `4.2.1`.\n- Until upgraded, keep lock files in a directory that other local accounts cannot read or write, such as a directory inside a user profile.","reach":"local","title":"filelock: Windows ignores lock mode, lock file inherits directory access","impact":"medium","summary":"On Windows, filelock ignores the mode argument, so a lock file or ReadWriteLock database created with mode=0o600 gets the parent directory's inherited permissions. Other local accounts that can read or write that directory can open the file, hold the byte-range lock to block the owner, or read holder metadata.","category":"package","nicknames":[],"who_cares":["python","windows","filelock"],"confidence":0.8,"needs_auth":"yes","worst_case":"Other local accounts can block lock owners or read and write lock state","analyst_note":"","how_to_check":"- Run `pip show filelock` on Windows hosts and check whether the version is between `3.10.0` and `4.2.0`.\n- Search code for `FileLock(` or `ReadWriteLock(` calls that pass `mode=0o600`, and check whether their lock directory grants other local accounts access to new files (inheritable ACL entries, `(OI)(CI)`).","needs_analyst":false,"not_affected_if":["unix-only","single-user-host","directory-excludes-other-accounts"],"who_is_affected":"Only Windows hosts running filelock 3.10.0 through 4.2.0 where callers rely on mode=0o600 for privacy across local accounts. The exposure requires the lock directory to hand down read or modify access to other accounts; Unix systems are not affected.","user_interaction":"no","needs_special_setup":"yes","severity_if_unknown":"unknown"},"cost_usd":0.001129,"input_tokens":8261,"output_tokens":606,"severity_before":"medium"},"analyst_status":null,"analyst_note":null,"search":"'-0':305C '-112910':19A,27A '-2026':18A,26A,304C '-732':30B,309C '/av':325C '0o600':6A,52B,98C,149C,244C,313C,388C,472C '3.1':322C,324C '3.10.0':285C '4.2.0':287C '5.3':335C '7m5m':23A '8mx5':22A 'ac':364C 'access':121C,125C,163C,234C,601C,665C 'accord':659C 'account':62B,162C,168C,267C,342C,356C,409C,436C,474C,506C,582C,633C,641C,654C 'acl':16A,128C,158C,250C,319C,637C 'acquir':205C,218C 'across':473C 'advisori':302C 'affect':281C,522C,717C,738C,739C 'alreadi':588C,638C 'also':411C,555C 'anoth':632C 'ant':303C 'anthrop':290C 'argument':41B,94C 'ask':146C 'asyncfilelock':527C 'asyncreadwritelock':538C 'attack':367C 'av':337C 'avail':432C 'bit':562C 'block':81B 'byte':77B,181C,190C,441C,672C 'byte-rang':76B,180C,440C,671C 'c':371C 'call':206C,492C 'caller':468C 'cannot':583C 'ci':620C 'claim':483C 'class':523C 'classif':456C 'code':740C 'complex':368C 'confidenti':374C 'confirm':499C 'cooper':734C 'corrupt':418C 'cover':299C 'creat':49B,99C,140C,549C,720C 'cve':17A,25A 'cvss':321C,323C 'cwe':29B,308C 'data':610C 'databas':12A,48B,143C,175C,384C,534C,707C 'descriptor':110C 'directori':15A,56B,69B,133C,155C,230C,318C,402C,576C,611C,617C,629C,635C 'document':246C,587C,663C 'drop':257C 'either':279C 'enough':358C,667C 'entri':595C,621C,622C 'evid':508C 'examin':572C 'exampl':605C 'exclud':639C 'exclus':270C,732C 'exist':689C 'failur':462C 'fchmod':730C 'fd':545C 'file':8A,45B,73B,102C,123C,138C,166C,173C,193C,225C,227C,240C,315C,378C,414C,604C,625C,658C,688C,703C,722C 'filelock':1A,28A,31B,37B,88C,95C,104C,139C,284C,525C 'find':298C 'follow':274C 'get':53B 'ghsa':21A 'ghsa-8mx5-7m5m-r77g':20A 'go':540C 'grant':159C,596C 'hand':134C,231C 'hide':649C 'hold':74B,277C,438C,678C,693C 'holder':86B,214C,379C 'hook':219C 'host':349C 'ignor':3A,38B,91C,311C 'impact':375C,399C,433C,465C 'inherit':13A,58B,157C,316C,594C,630C 'insid':645C 'integr':398C 'interact':363C 'keep':200C,265C,392C,516C,556C 'keo0ddo':306C 'l':333C,338C,351C,365C,372C,396C,430C 'l/a':332C 'l/ac':326C 'l/i':331C 'l/pr':327C 'l/ui':328C 'later':204C 'layout':403C 'left':220C 'let':416C 'linux':494C 'list':126C 'local':61B,161C,339C,505C,581C 'lock':7A,44B,79B,132C,172C,183C,185C,224C,314C,377C,383C,420C,427C,443C,548C,674C,680C,687C,695C,702C 'lock.mode':241C 'lockfileex':662C 'logon':345C 'low':352C,366C 'maintain':405C,496C,515C 'make':445C 'mark':478C 'marker':551C 'may':120C 'meant':390C 'medium':307C,336C,513C,517C 'metadata':87B,215C,380C 'mode':4A,40B,51B,93C,97C,259C,264C,312C,471C,565C,725C 'modifi':233C,600C 'must':655C 'mutual':269C,731C 'n':360C 'n/s':329C 'need':343C 'neither':247C 'new':137C,165C,603C,624C 'non':543C 'noth':425C 'oi':619C 'one':106C,578C,644C 'open':71B,170C,542C,656C 'ordinari':355C 'os.open':553C 'oss':292C 'owner':83B,196C,202C,447C,683C,692C 'packag':32B 'parent':55B 'partial':373C,397C,431C 'path':96C,105C 'permiss':59B,461C 'platform':280C 'point':713C 'pr':350C 'precondit':520C 'preserv':223C,701C 'privat':297C,394C 'privileg':353C 'problem':651C 'process':272C,735C 'profil':648C 'promis':248C 'protect':428C 'protocol':276C 'python':33B 'r77g':24A 'race':370C 'rang':78B,182C,442C,673C 'rate':511C 'read':65B,85B,213C,560C,598C,664C 'read-on':559C 'readabl':386C,612C 'readwritelock':11A,47B,142C,536C,706C 'record':116C 'releas':197C,699C 'reli':469C 'repars':544C 'repeat':727C 'report':243C,294C 'requir':589C 'review':459C,476C 'say':118C,254C 'scann':741C 'scanner':293C,486C,510C,569C 'scope':454C,518C 'score':334C 'secur':109C,464C 'see':507C 'servic':608C 'sever':320C 'sinc':484C,498C 'soft':547C 'span':188C 'sqlite':533C 'stand':489C 'stand-in':488C 'state':423C 'stay':697C 'still':242C 'sub':628C 'sub-directori':627C 'take':178C,669C 'test':406C 'time':209C,450C 'trace':487C 'true':226C,704C 'two':504C 'u':453C 'u/c':330C 'ui':359C 'unchang':455C 'unconfirm':481C 'unix':261C,714C 'unixfilelock':719C 'unlink':710C 'user':362C,614C,647C 'version':282C 'wait':207C,448C 'way':152C 'whatev':130C 'whenev':681C 'whose':156C,593C,636C 'win32':491C 'window':34B,36B,90C,115C,252C,256C,289C,460C,482C,502C,529C,567C,591C 'windowsfilelock':2A,310C,530C 'write':67B,237C,412C,584C","nicknames":[],"mitigations":[],"who_affected":"Only Windows hosts running filelock 3.10.0 through 4.2.0 where callers rely on mode=0o600 for privacy across local accounts. The exposure requires the lock directory to hand down read or modify access to other accounts; Unix systems are not affected.","tier":"C","verified":{},"analyst_revisit_at":null,"first_public_at":"2026-10-28T21:08:55+00:00","kev":null,"cvss_vector":"CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:L","cvss_by":"GitHub","poc_count":0,"sources":[{"source":"ghsa","external_id":"GHSA-8mx5-7m5m-r77g","url":"https://github.com/advisories/GHSA-8mx5-7m5m-r77g","severity":"medium","published_at":"2026-10-28T21:08:55+00:00","modified_at":"2026-10-28T21:08:55+00:00","first_seen_at":"2026-10-28T21:12:45+00:00","fetched_at":"2026-10-28T21:12:45+00:00","note":null}],"documents":[],"notice":"Free to read at a human pace. An API with keys and an MCP server are in preparation; early access: hello@infrastack.ai"}