<?xml version='1.0' encoding='UTF-8'?>
<?xml-stylesheet href="/static/style.xsl" type="text/xsl"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
  <id>https://cve.radiocsirt.org/rss/recent/all/10</id>
  <title>Most recent entries from all</title>
  <updated>2026-11-16T22:54:28.904379+00:00</updated>
  <author>
    <name>Vulnerability-Lookup</name>
    <email>csirt@opendfir.org</email>
  </author>
  <link href="https://cve.radiocsirt.org" rel="alternate"/>
  <generator uri="https://lkiesow.github.io/python-feedgen" version="1.0.0">python-feedgen</generator>
  <subtitle>Contains only the most 10 recent entries.</subtitle>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/brew-krane-cve-2026-126354</id>
    <title>BREW-krane-CVE-2026-126354 — Addressable URI normalization resolves some dotted path segments to the wrong path</title>
    <updated>2026-11-16T22:54:28.909890+00:00</updated>
    <content type="xhtml">
      <div xmlns="http://www.w3.org/1999/xhtml"><p><strong>Affected:</strong> Homebrew: krane</p>
<p>### Summary</p>
<p>`Addressable::URI.normalize_path` resolves some paths containing `..` segments to a different path than RFC 3986 does. When a path climbs above the root before any other `..` is resolved, the segments that later `..` segments should remove are instead kept: `/../../public/x/../../secret` normalizes to `/public/x/secret` instead of `/secret`. `URI#normalize`, `URI#join`, `URI#==` and `URI#===` all use this normalization. An application that checks a normalized Addressable path against an allowlist, but sends the original URI to something that resolves it according to RFC 3986, can be made to allow a request for a path outside the allowlist.</p>
<p>### Details</p>
<p>`normalize_path` in 2.9.0 (`lib/addressable/uri.rb`) removes dot segments by repeating a set of rewrites until nothing changes. On each pass it finds the first `/segment/../` pair with `RULE_2B_2C`, then replaces every textual copy of that pair in the path with `/`:</p>
<p>```ruby
pair = normalized_path.match(RULE_2B_2C)
...
regexp = "/#{Regexp.escape(parent.to_s)}/\\.\\./|"
regexp += "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
...
mod ||= normalized_path.gsub!(Regexp.new(regexp), SLASH)
```</p>
<p>When the first pair found is `/../../`, where the "segment" is itself `..`, every `/../../` in the path is replaced with `/`. That includes copies later in the path, where each `..` should have removed the segment before it. For `/../../public/x/../../secret`:</p>
<p>- RFC 3986 §5.2.4 drops the two leading `..` segments, which can't go…</p></div>
    </content>
    <link href="https://cve.radiocsirt.org/vuln/brew-krane-cve-2026-126354"/>
  </entry>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/euvd-2026-405794</id>
    <title>EUVD-2026-405794</title>
    <updated>2026-11-16T22:54:28.909965+00:00</updated>
    <content>EUVD-2026-405794</content>
    <link href="https://cve.radiocsirt.org/vuln/euvd-2026-405794"/>
  </entry>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/fkie_cve-2026-126354</id>
    <title>fkie_cve-2026-126354</title>
    <updated>2026-11-16T22:54:28.909982+00:00</updated>
    <content type="xhtml">
      <div xmlns="http://www.w3.org/1999/xhtml">
        <p>Addressable is an alternative implementation to the URI implementation that is part of Ruby's standard library. From 2.2.5 until 2.9.1, Addressable::URI.normalize_path can resolve a path containing leading parent segments and later parent segments to a different path than an RFC 3986 resolver. URI#normalize, URI#join, URI#==, and URI#=== inherit the result. An application that authorizes the Addressable-normalized path but sends the original URI to another resolver can allow access outside the intended path allowlist. Applications that use the same normalized value for authorization and the request, or reject parent segments, are unaffected. This issue is fixed in version 2.9.1.</p>
      </div>
    </content>
    <link href="https://cve.radiocsirt.org/vuln/fkie_cve-2026-126354"/>
  </entry>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/ghsa-8gmh-2hhj-2hv9</id>
    <title>GHSA-8gmh-2hhj-2hv9 — Addressable URI normalization resolves some dotted path segments to the wrong path</title>
    <updated>2026-11-16T22:54:28.910008+00:00</updated>
    <content type="xhtml">
      <div xmlns="http://www.w3.org/1999/xhtml"><p><strong>Affected:</strong> RubyGems: addressable</p>
<p>### Summary</p>
<p>`Addressable::URI.normalize_path` resolves some paths containing `..` segments to a different path than RFC 3986 does. When a path climbs above the root before any other `..` is resolved, the segments that later `..` segments should remove are instead kept: `/../../public/x/../../secret` normalizes to `/public/x/secret` instead of `/secret`. `URI#normalize`, `URI#join`, `URI#==` and `URI#===` all use this normalization. An application that checks a normalized Addressable path against an allowlist, but sends the original URI to something that resolves it according to RFC 3986, can be made to allow a request for a path outside the allowlist.</p>
<p>### Details</p>
<p>`normalize_path` in 2.9.0 (`lib/addressable/uri.rb`) removes dot segments by repeating a set of rewrites until nothing changes. On each pass it finds the first `/segment/../` pair with `RULE_2B_2C`, then replaces every textual copy of that pair in the path with `/`:</p>
<p>```ruby
pair = normalized_path.match(RULE_2B_2C)
...
regexp = "/#{Regexp.escape(parent.to_s)}/\\.\\./|"
regexp += "(/#{Regexp.escape(current.to_s)}/\\.\\.$)"
...
mod ||= normalized_path.gsub!(Regexp.new(regexp), SLASH)
```</p>
<p>When the first pair found is `/../../`, where the "segment" is itself `..`, every `/../../` in the path is replaced with `/`. That includes copies later in the path, where each `..` should have removed the segment before it. For `/../../public/x/../../secret`:</p>
<p>- RFC 3986 §5.2.4 drops the two leading `..` segments, which can't go…</p></div>
    </content>
    <link href="https://cve.radiocsirt.org/vuln/ghsa-8gmh-2hhj-2hv9"/>
  </entry>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/msrc_cve-2026-126354</id>
    <title>msrc_CVE-2026-126354 — Addressable URI normalization resolves some dotted path segments to the wrong path</title>
    <updated>2026-11-16T22:54:28.910054+00:00</updated>
    <content>msrc_CVE-2026-126354</content>
    <link href="https://cve.radiocsirt.org/vuln/msrc_cve-2026-126354"/>
  </entry>
  <entry>
    <id>https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-126354</id>
    <title>UBUNTU-CVE-2026-126354</title>
    <updated>2026-11-16T22:54:28.910070+00:00</updated>
    <content type="xhtml">
      <div xmlns="http://www.w3.org/1999/xhtml"><p><strong>Affected:</strong> 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</p>
<p>Addressable is an alternative implementation to the URI implementation that is part of Ruby's standard library. From 2.2.5 until 2.9.1, Addressable::URI.normalize_path can resolve a path containing leading parent segments and later parent segments to a different path than an RFC 3986 resolver. URI#normalize, URI#join, URI#==, and URI#=== inherit the result. An application that authorizes the Addressable-normalized path but sends the original URI to another resolver can allow access outside the intended path allowlist. Applications that use the same normalized value for authorization and the request, or reject parent segments, are unaffected. This issue is fixed in version 2.9.1.</p></div>
    </content>
    <link href="https://cve.radiocsirt.org/vuln/ubuntu-cve-2026-126354"/>
  </entry>
</feed>
