<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="/static/style.xsl" type="text/xsl"?>
<rss xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/" version="2.0">
  <channel>
    <title>Most recent entries from all</title>
    <link>https://cve.radiocsirt.org</link>
    <description>Contains only the most 10 recent entries.</description>
    <docs>http://www.rssboard.org/rss-specification</docs>
    <generator>python-feedgen</generator>
    <language>en</language>
    <lastBuildDate>Mon, 16 Nov 2026 19:25:16 +0000</lastBuildDate>
    <item>
      <title>BREW-ansible-lint-CVE-2026-112940 — filelock ReadWriteLock: SQLite reopens the lock database by name, so a planted symlink or journal file makes the lock u…</title>
      <link>https://cve.radiocsirt.org/vuln/brew-ansible-lint-cve-2026-112940</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Homebrew: ansible-lint&lt;/p&gt;
&lt;p&gt;`ReadWriteLock` and `AsyncReadWriteLock` (the SQLite-backed reader/writer lock) hand SQLite a name they do not control. On Linux the lock validates its database through a descriptor (the number the kernel gives a process for an open file). It then connects SQLite to `/proc/self/fd/&amp;lt;n&amp;gt;`, a Linux path that names the process&amp;#39;s own open file `n`. SQLite turns that path back into a plain path and reopens it by name, following symlinks (a symlink is a file that points at another path). On every POSIX route SQLite also acts on `-journal`, `-wal` and `-shm` files it finds beside that name. Those are SQLite&amp;#39;s side files: the rollback journal (pages saved to undo an interrupted write), the write-ahead log or WAL (changes kept outside the main file), and the shared-memory index for the WAL.&lt;/p&gt;
&lt;p&gt;Another local user who can create or rename entries in the directory that holds the lock database can turn this against the user running the lock (below: the lock user). Such a directory is a `0777` or group-writable cache, build or project directory without the sticky bit (a directory flag that lets only a file&amp;#39;s owner remove or rename it). That other user can make the lock user&amp;#39;s ordinary `read_lock()` or `write_lock()` write bytes of the other user&amp;#39;s choosing into the lock user&amp;#39;s own files. The same position lets the other user make that call create or unlink files of the lock user, admit a reader beside a writer, or kill the holder. All of this runs with the lock user&amp;#39;s privileges. In a sticky…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Homebrew: ansible-lint&lt;/p&gt;
&lt;p&gt;`ReadWriteLock` and `AsyncReadWriteLock` (the SQLite-backed reader/writer lock) hand SQLite a name they do not control. On Linux the lock validates its database through a descriptor (the number the kernel gives a process for an open file). It then connects SQLite to `/proc/self/fd/&amp;lt;n&amp;gt;`, a Linux path that names the process&amp;#39;s own open file `n`. SQLite turns that path back into a plain path and reopens it by name, following symlinks (a symlink is a file that points at another path). On every POSIX route SQLite also acts on `-journal`, `-wal` and `-shm` files it finds beside that name. Those are SQLite&amp;#39;s side files: the rollback journal (pages saved to undo an interrupted write), the write-ahead log or WAL (changes kept outside the main file), and the shared-memory index for the WAL.&lt;/p&gt;
&lt;p&gt;Another local user who can create or rename entries in the directory that holds the lock database can turn this against the user running the lock (below: the lock user). Such a directory is a `0777` or group-writable cache, build or project directory without the sticky bit (a directory flag that lets only a file&amp;#39;s owner remove or rename it). That other user can make the lock user&amp;#39;s ordinary `read_lock()` or `write_lock()` write bytes of the other user&amp;#39;s choosing into the lock user&amp;#39;s own files. The same position lets the other user make that call create or unlink files of the lock user, admit a reader beside a writer, or kill the holder. All of this runs with the lock user&amp;#39;s privileges. In a sticky…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/brew-ansible-lint-cve-2026-112940</guid>
    </item>
    <item>
      <title>CLEANSTART-2026-AE20147 — filelock is a platform-independent file lock for Python</title>
      <link>https://cve.radiocsirt.org/vuln/cleanstart-2026-ae20147</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; CleanStart: litellm-database&lt;/p&gt;
&lt;p&gt;Security vulnerability affects the litellm-database package. filelock is a platform-independent file lock for Python.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; CleanStart: litellm-database&lt;/p&gt;
&lt;p&gt;Security vulnerability affects the litellm-database package. filelock is a platform-independent file lock for Python.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/cleanstart-2026-ae20147</guid>
    </item>
    <item>
      <title>EUVD-2026-391306</title>
      <link>https://cve.radiocsirt.org/vuln/euvd-2026-391306</link>
      <description>EUVD-2026-391306</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/euvd-2026-391306</guid>
    </item>
    <item>
      <title>fkie_cve-2026-112940</title>
      <link>https://cve.radiocsirt.org/vuln/fkie_cve-2026-112940</link>
      <description>&lt;p&gt;filelock is a platform-independent file lock for Python. From 3.20.4 until 4.2.1, ReadWriteLock let SQLite reopen the database and side files by name; on POSIX systems an attacker with rename access in a non-sticky parent can swap those names to cause overwrite or unlink operations, while a writable adjacent hot journal is additionally required for attacker-chosen content overwrites. This issue is fixed in version 4.2.1.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;filelock is a platform-independent file lock for Python. From 3.20.4 until 4.2.1, ReadWriteLock let SQLite reopen the database and side files by name; on POSIX systems an attacker with rename access in a non-sticky parent can swap those names to cause overwrite or unlink operations, while a writable adjacent hot journal is additionally required for attacker-chosen content overwrites. This issue is fixed in version 4.2.1.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/fkie_cve-2026-112940</guid>
    </item>
    <item>
      <title>GHSA-v4x8-3wr5-3wq8 — filelock ReadWriteLock: SQLite reopens the lock database by name, so a planted symlink or journal file makes the lock u…</title>
      <link>https://cve.radiocsirt.org/vuln/ghsa-v4x8-3wr5-3wq8</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: filelock&lt;/p&gt;
&lt;p&gt;`ReadWriteLock` and `AsyncReadWriteLock` (the SQLite-backed reader/writer lock) hand SQLite a name they do not control. On Linux the lock validates its database through a descriptor (the number the kernel gives a process for an open file). It then connects SQLite to `/proc/self/fd/&amp;lt;n&amp;gt;`, a Linux path that names the process&amp;#39;s own open file `n`. SQLite turns that path back into a plain path and reopens it by name, following symlinks (a symlink is a file that points at another path). On every POSIX route SQLite also acts on `-journal`, `-wal` and `-shm` files it finds beside that name. Those are SQLite&amp;#39;s side files: the rollback journal (pages saved to undo an interrupted write), the write-ahead log or WAL (changes kept outside the main file), and the shared-memory index for the WAL.&lt;/p&gt;
&lt;p&gt;Another local user who can create or rename entries in the directory that holds the lock database can turn this against the user running the lock (below: the lock user). Such a directory is a `0777` or group-writable cache, build or project directory without the sticky bit (a directory flag that lets only a file&amp;#39;s owner remove or rename it). That other user can make the lock user&amp;#39;s ordinary `read_lock()` or `write_lock()` write bytes of the other user&amp;#39;s choosing into the lock user&amp;#39;s own files. The same position lets the other user make that call create or unlink files of the lock user, admit a reader beside a writer, or kill the holder. All of this runs with the lock user&amp;#39;s privileges. In a sticky…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; PyPI: filelock&lt;/p&gt;
&lt;p&gt;`ReadWriteLock` and `AsyncReadWriteLock` (the SQLite-backed reader/writer lock) hand SQLite a name they do not control. On Linux the lock validates its database through a descriptor (the number the kernel gives a process for an open file). It then connects SQLite to `/proc/self/fd/&amp;lt;n&amp;gt;`, a Linux path that names the process&amp;#39;s own open file `n`. SQLite turns that path back into a plain path and reopens it by name, following symlinks (a symlink is a file that points at another path). On every POSIX route SQLite also acts on `-journal`, `-wal` and `-shm` files it finds beside that name. Those are SQLite&amp;#39;s side files: the rollback journal (pages saved to undo an interrupted write), the write-ahead log or WAL (changes kept outside the main file), and the shared-memory index for the WAL.&lt;/p&gt;
&lt;p&gt;Another local user who can create or rename entries in the directory that holds the lock database can turn this against the user running the lock (below: the lock user). Such a directory is a `0777` or group-writable cache, build or project directory without the sticky bit (a directory flag that lets only a file&amp;#39;s owner remove or rename it). That other user can make the lock user&amp;#39;s ordinary `read_lock()` or `write_lock()` write bytes of the other user&amp;#39;s choosing into the lock user&amp;#39;s own files. The same position lets the other user make that call create or unlink files of the lock user, admit a reader beside a writer, or kill the holder. All of this runs with the lock user&amp;#39;s privileges. In a sticky…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ghsa-v4x8-3wr5-3wq8</guid>
    </item>
    <item>
      <title>RHSA-2026:92510 — Red Hat Security Advisory: RHOAI 3.4.6 - Red Hat OpenShift AI</title>
      <link>https://cve.radiocsirt.org/vuln/rhsa-2026:92510</link>
      <description>&lt;p&gt;sqlite: SQLite: Arbitrary code execution via crafted FTS5 full-text search data sqlite: SQLite: Arbitrary code execution and crash via heap-based buffer overflow in FTS5 RHOAI MaaS: llm-d: MaaS/llm-d inference Gateway: default allowedRoutes.namespaces.from: All allows namespace users to hijack shared model-serving traffic (tokens, prompts, outputs) fast-uri: Fast-uri: Security policy bypass due to URL parsing inconsistency github.com/moby/go-archive: moby/go-archive: Arbitrary file write via link following in tar extraction fast-uri: fast-uri: Host confusion vulnerability via backslash in URI authority golang.org/x/net/html: golang.org/x/net/html: Arbitrary code execution via Cross-Site Scripting cryptography: cryptography Subgroup Attack Due to Missing Subgroup Validation for SECT Curves golang.org/x/net/html: golang: golang.org/x/net/html: Cross-Site Scripting via HTML parsing bypass net/http/internal/http2: golang: golang.org/x/net: Go HTTP/2: Denial of Service via malformed SETTINGS_MAX_FRAME_SIZE frame encoding/asn1: golang: Go encoding/asn1: Denial of Service via excessive recursion in Unmarshal golang.org/x/net/idna: golang: net/http: golang.org/x/net/idna: Privilege escalation via incorrect Punycode label processing golang.org/x/crypto/ssh: golang: golang.org/x/crypto/ssh: Denial of Service due to integer overflow in SSH channel write github.com/open-telemetry/opentelemetry-go: go.opentelemetry.io/otel/baggage: go.opentelemetry.io/otel/propagation: OpenTelemetry-Go:…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;sqlite: SQLite: Arbitrary code execution via crafted FTS5 full-text search data sqlite: SQLite: Arbitrary code execution and crash via heap-based buffer overflow in FTS5 RHOAI MaaS: llm-d: MaaS/llm-d inference Gateway: default allowedRoutes.namespaces.from: All allows namespace users to hijack shared model-serving traffic (tokens, prompts, outputs) fast-uri: Fast-uri: Security policy bypass due to URL parsing inconsistency github.com/moby/go-archive: moby/go-archive: Arbitrary file write via link following in tar extraction fast-uri: fast-uri: Host confusion vulnerability via backslash in URI authority golang.org/x/net/html: golang.org/x/net/html: Arbitrary code execution via Cross-Site Scripting cryptography: cryptography Subgroup Attack Due to Missing Subgroup Validation for SECT Curves golang.org/x/net/html: golang: golang.org/x/net/html: Cross-Site Scripting via HTML parsing bypass net/http/internal/http2: golang: golang.org/x/net: Go HTTP/2: Denial of Service via malformed SETTINGS_MAX_FRAME_SIZE frame encoding/asn1: golang: Go encoding/asn1: Denial of Service via excessive recursion in Unmarshal golang.org/x/net/idna: golang: net/http: golang.org/x/net/idna: Privilege escalation via incorrect Punycode label processing golang.org/x/crypto/ssh: golang: golang.org/x/crypto/ssh: Denial of Service due to integer overflow in SSH channel write github.com/open-telemetry/opentelemetry-go: go.opentelemetry.io/otel/baggage: go.opentelemetry.io/otel/propagation: OpenTelemetry-Go:…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/rhsa-2026:92510</guid>
    </item>
    <item>
      <title>UBUNTU-CVE-2026-112940</title>
      <link>https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-112940</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:18.04:LTS: python-filelock, Ubuntu:Pro:20.04:LTS: python-filelock, Ubuntu:Pro:22.04:LTS: python-filelock, Ubuntu:Pro:24.04:LTS: python-filelock, Ubuntu:26.10: python-filelock, Ubuntu:26.04:LTS: python-filelock&lt;/p&gt;
&lt;p&gt;filelock is a platform-independent file lock for Python. From 3.20.4 until 4.2.1, ReadWriteLock let SQLite reopen the database and side files by name; on POSIX systems an attacker with rename access in a non-sticky parent can swap those names to cause overwrite or unlink operations, while a writable adjacent hot journal is additionally required for attacker-chosen content overwrites. This issue is fixed in version 4.2.1.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:18.04:LTS: python-filelock, Ubuntu:Pro:20.04:LTS: python-filelock, Ubuntu:Pro:22.04:LTS: python-filelock, Ubuntu:Pro:24.04:LTS: python-filelock, Ubuntu:26.10: python-filelock, Ubuntu:26.04:LTS: python-filelock&lt;/p&gt;
&lt;p&gt;filelock is a platform-independent file lock for Python. From 3.20.4 until 4.2.1, ReadWriteLock let SQLite reopen the database and side files by name; on POSIX systems an attacker with rename access in a non-sticky parent can swap those names to cause overwrite or unlink operations, while a writable adjacent hot journal is additionally required for attacker-chosen content overwrites. This issue is fixed in version 4.2.1.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-112940</guid>
    </item>
  </channel>
</rss>
