<?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 21:33:37 +0000</lastBuildDate>
    <item>
      <title>BREW-krane-CVE-2026-126351 — Addressable: Denial of service in URI path normalization</title>
      <link>https://cve.radiocsirt.org/vuln/brew-krane-cve-2026-126351</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Homebrew: krane&lt;/p&gt;
&lt;p&gt;### Impact&lt;/p&gt;
&lt;p&gt;`Addressable::URI.normalize_path` takes time quadratic in the number of nested dot segments in a path (e.g., `&amp;#34;/&amp;#34; + &amp;#34;a/&amp;#34; * n + &amp;#34;../&amp;#34; * n`, which for n = 3 is `/a/a/a/../../../`), because it removes one dot segment per pass over the whole path. `URI#normalize`, `URI#normalized_path`, `URI#==`, `URI#===` and `URI#join` all call it. Normalizing, comparing or joining a URI taken from user input can result in uncontrolled resource consumption, leading to denial of service. On 2.9.0, normalizing a 34 KB path takes about 3.5 seconds on MRI Ruby 4.0, and the cost grows with the square of the path length.&lt;/p&gt;
&lt;p&gt;This affects every Ruby implementation, including MRI Ruby 3.2 and later. `URI.parse` by itself is unaffected, as is code that never normalizes, compares, or joins URIs from untrusted sources.&lt;/p&gt;
&lt;p&gt;### Affected Versions&lt;/p&gt;
&lt;p&gt;This vulnerability affects all versions of Addressable prior to 2.9.1. It is fixed in 2.9.1.&lt;/p&gt;
&lt;p&gt;### Workarounds&lt;/p&gt;
&lt;p&gt;- Limit the length of URIs taken from user input before calling `normalize`, `==` or `join` on them. Web servers often limit request lines to about 8 KB, which keeps the cost to about 150 milliseconds per call on typical hardware, but URIs from other sources (request bodies, headers such as `Location`, stored data) may not be limited.
- Reject paths with many dot segments before normalizing them.&lt;/p&gt;
&lt;p&gt;### Credits&lt;/p&gt;
&lt;p&gt;Reported by Matthew Mongeau (@halogenandtoast), Ruby Central Gem Security, who also suggested the single-pass approach used in the fix.&lt;/p&gt;
&lt;p&gt;###…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Homebrew: krane&lt;/p&gt;
&lt;p&gt;### Impact&lt;/p&gt;
&lt;p&gt;`Addressable::URI.normalize_path` takes time quadratic in the number of nested dot segments in a path (e.g., `&amp;#34;/&amp;#34; + &amp;#34;a/&amp;#34; * n + &amp;#34;../&amp;#34; * n`, which for n = 3 is `/a/a/a/../../../`), because it removes one dot segment per pass over the whole path. `URI#normalize`, `URI#normalized_path`, `URI#==`, `URI#===` and `URI#join` all call it. Normalizing, comparing or joining a URI taken from user input can result in uncontrolled resource consumption, leading to denial of service. On 2.9.0, normalizing a 34 KB path takes about 3.5 seconds on MRI Ruby 4.0, and the cost grows with the square of the path length.&lt;/p&gt;
&lt;p&gt;This affects every Ruby implementation, including MRI Ruby 3.2 and later. `URI.parse` by itself is unaffected, as is code that never normalizes, compares, or joins URIs from untrusted sources.&lt;/p&gt;
&lt;p&gt;### Affected Versions&lt;/p&gt;
&lt;p&gt;This vulnerability affects all versions of Addressable prior to 2.9.1. It is fixed in 2.9.1.&lt;/p&gt;
&lt;p&gt;### Workarounds&lt;/p&gt;
&lt;p&gt;- Limit the length of URIs taken from user input before calling `normalize`, `==` or `join` on them. Web servers often limit request lines to about 8 KB, which keeps the cost to about 150 milliseconds per call on typical hardware, but URIs from other sources (request bodies, headers such as `Location`, stored data) may not be limited.
- Reject paths with many dot segments before normalizing them.&lt;/p&gt;
&lt;p&gt;### Credits&lt;/p&gt;
&lt;p&gt;Reported by Matthew Mongeau (@halogenandtoast), Ruby Central Gem Security, who also suggested the single-pass approach used in the fix.&lt;/p&gt;
&lt;p&gt;###…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/brew-krane-cve-2026-126351</guid>
    </item>
    <item>
      <title>EUVD-2026-405791</title>
      <link>https://cve.radiocsirt.org/vuln/euvd-2026-405791</link>
      <description>EUVD-2026-405791</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/euvd-2026-405791</guid>
    </item>
    <item>
      <title>fkie_cve-2026-126351</title>
      <link>https://cve.radiocsirt.org/vuln/fkie_cve-2026-126351</link>
      <description>&lt;p&gt;Addressable is an alternative implementation to the URI implementation that is part of Ruby&amp;#39;s standard library. Prior to 2.9.1, Addressable::URI.normalize_path repeatedly scans and rewrites paths while removing only one nested dot segment per pass, producing quadratic work. URI#normalize, URI#normalized_path, URI#join, URI#==, and URI#=== inherit the behavior, so processing a sufficiently long attacker-controlled URI can consume a worker thread and cause denial of service on every Ruby implementation. URI.parse alone and code that never normalizes, compares, or joins untrusted URIs are unaffected. This issue is fixed in version 2.9.1.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;Addressable is an alternative implementation to the URI implementation that is part of Ruby&amp;#39;s standard library. Prior to 2.9.1, Addressable::URI.normalize_path repeatedly scans and rewrites paths while removing only one nested dot segment per pass, producing quadratic work. URI#normalize, URI#normalized_path, URI#join, URI#==, and URI#=== inherit the behavior, so processing a sufficiently long attacker-controlled URI can consume a worker thread and cause denial of service on every Ruby implementation. URI.parse alone and code that never normalizes, compares, or joins untrusted URIs are unaffected. This issue is fixed in version 2.9.1.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/fkie_cve-2026-126351</guid>
    </item>
    <item>
      <title>GHSA-qq38-m9mg-xjj5 — Addressable: Denial of service in URI path normalization</title>
      <link>https://cve.radiocsirt.org/vuln/ghsa-qq38-m9mg-xjj5</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; RubyGems: addressable&lt;/p&gt;
&lt;p&gt;### Impact&lt;/p&gt;
&lt;p&gt;`Addressable::URI.normalize_path` takes time quadratic in the number of nested dot segments in a path (e.g., `&amp;#34;/&amp;#34; + &amp;#34;a/&amp;#34; * n + &amp;#34;../&amp;#34; * n`, which for n = 3 is `/a/a/a/../../../`), because it removes one dot segment per pass over the whole path. `URI#normalize`, `URI#normalized_path`, `URI#==`, `URI#===` and `URI#join` all call it. Normalizing, comparing or joining a URI taken from user input can result in uncontrolled resource consumption, leading to denial of service. On 2.9.0, normalizing a 34 KB path takes about 3.5 seconds on MRI Ruby 4.0, and the cost grows with the square of the path length.&lt;/p&gt;
&lt;p&gt;This affects every Ruby implementation, including MRI Ruby 3.2 and later. `URI.parse` by itself is unaffected, as is code that never normalizes, compares, or joins URIs from untrusted sources.&lt;/p&gt;
&lt;p&gt;### Affected Versions&lt;/p&gt;
&lt;p&gt;This vulnerability affects all versions of Addressable prior to 2.9.1. It is fixed in 2.9.1.&lt;/p&gt;
&lt;p&gt;### Workarounds&lt;/p&gt;
&lt;p&gt;- Limit the length of URIs taken from user input before calling `normalize`, `==` or `join` on them. Web servers often limit request lines to about 8 KB, which keeps the cost to about 150 milliseconds per call on typical hardware, but URIs from other sources (request bodies, headers such as `Location`, stored data) may not be limited.
- Reject paths with many dot segments before normalizing them.&lt;/p&gt;
&lt;p&gt;### Credits&lt;/p&gt;
&lt;p&gt;Reported by Matthew Mongeau (@halogenandtoast), Ruby Central Gem Security, who also suggested the single-pass approach used in the fix.&lt;/p&gt;
&lt;p&gt;###…&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; RubyGems: addressable&lt;/p&gt;
&lt;p&gt;### Impact&lt;/p&gt;
&lt;p&gt;`Addressable::URI.normalize_path` takes time quadratic in the number of nested dot segments in a path (e.g., `&amp;#34;/&amp;#34; + &amp;#34;a/&amp;#34; * n + &amp;#34;../&amp;#34; * n`, which for n = 3 is `/a/a/a/../../../`), because it removes one dot segment per pass over the whole path. `URI#normalize`, `URI#normalized_path`, `URI#==`, `URI#===` and `URI#join` all call it. Normalizing, comparing or joining a URI taken from user input can result in uncontrolled resource consumption, leading to denial of service. On 2.9.0, normalizing a 34 KB path takes about 3.5 seconds on MRI Ruby 4.0, and the cost grows with the square of the path length.&lt;/p&gt;
&lt;p&gt;This affects every Ruby implementation, including MRI Ruby 3.2 and later. `URI.parse` by itself is unaffected, as is code that never normalizes, compares, or joins URIs from untrusted sources.&lt;/p&gt;
&lt;p&gt;### Affected Versions&lt;/p&gt;
&lt;p&gt;This vulnerability affects all versions of Addressable prior to 2.9.1. It is fixed in 2.9.1.&lt;/p&gt;
&lt;p&gt;### Workarounds&lt;/p&gt;
&lt;p&gt;- Limit the length of URIs taken from user input before calling `normalize`, `==` or `join` on them. Web servers often limit request lines to about 8 KB, which keeps the cost to about 150 milliseconds per call on typical hardware, but URIs from other sources (request bodies, headers such as `Location`, stored data) may not be limited.
- Reject paths with many dot segments before normalizing them.&lt;/p&gt;
&lt;p&gt;### Credits&lt;/p&gt;
&lt;p&gt;Reported by Matthew Mongeau (@halogenandtoast), Ruby Central Gem Security, who also suggested the single-pass approach used in the fix.&lt;/p&gt;
&lt;p&gt;###…&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ghsa-qq38-m9mg-xjj5</guid>
    </item>
    <item>
      <title>msrc_CVE-2026-126351 — Addressable: Denial of service in URI path normalization</title>
      <link>https://cve.radiocsirt.org/vuln/msrc_cve-2026-126351</link>
      <description>msrc_CVE-2026-126351</description>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/msrc_cve-2026-126351</guid>
    </item>
    <item>
      <title>UBUNTU-CVE-2026-126351</title>
      <link>https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-126351</link>
      <description>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:16.04:LTS: ruby-addressable, Ubuntu:Pro:18.04:LTS: ruby-addressable, Ubuntu:Pro:20.04:LTS: ruby-addressable, Ubuntu:Pro:22.04:LTS: ruby-addressable, Ubuntu:Pro:24.04:LTS: ruby-addressable, Ubuntu:26.10: ruby-addressable, Ubuntu:Pro:26.04:LTS: ruby-addressable&lt;/p&gt;
&lt;p&gt;Addressable is an alternative implementation to the URI implementation that is part of Ruby&amp;#39;s standard library. Prior to 2.9.1, Addressable::URI.normalize_path repeatedly scans and rewrites paths while removing only one nested dot segment per pass, producing quadratic work. URI#normalize, URI#normalized_path, URI#join, URI#==, and URI#=== inherit the behavior, so processing a sufficiently long attacker-controlled URI can consume a worker thread and cause denial of service on every Ruby implementation. URI.parse alone and code that never normalizes, compares, or joins untrusted URIs are unaffected. This issue is fixed in version 2.9.1.&lt;/p&gt;</description>
      <content:encoded>&lt;p&gt;&lt;strong&gt;Affected:&lt;/strong&gt; Ubuntu:Pro:16.04:LTS: ruby-addressable, Ubuntu:Pro:18.04:LTS: ruby-addressable, Ubuntu:Pro:20.04:LTS: ruby-addressable, Ubuntu:Pro:22.04:LTS: ruby-addressable, Ubuntu:Pro:24.04:LTS: ruby-addressable, Ubuntu:26.10: ruby-addressable, Ubuntu:Pro:26.04:LTS: ruby-addressable&lt;/p&gt;
&lt;p&gt;Addressable is an alternative implementation to the URI implementation that is part of Ruby&amp;#39;s standard library. Prior to 2.9.1, Addressable::URI.normalize_path repeatedly scans and rewrites paths while removing only one nested dot segment per pass, producing quadratic work. URI#normalize, URI#normalized_path, URI#join, URI#==, and URI#=== inherit the behavior, so processing a sufficiently long attacker-controlled URI can consume a worker thread and cause denial of service on every Ruby implementation. URI.parse alone and code that never normalizes, compares, or joins untrusted URIs are unaffected. This issue is fixed in version 2.9.1.&lt;/p&gt;</content:encoded>
      <guid isPermaLink="false">https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-126351</guid>
    </item>
  </channel>
</rss>
