TL;DR
‍
The Ruby core team has fixed seven memory corruption vulnerabilities in Ruby's regular expression engine and in the way Ruby changes the case of strings. Ruby's maintainers say proofs of concept show that some of them can lead to remote code execution. This page tracks what is public, explains what it means for the Ruby applications you run and shows how Miggo can protect you while you upgrade.

Last updated: November 19, 2026, 10:49 IST. This page is updated on a rolling basis as new details become public.

The Short of It

  • On November 18, 2026, the Ruby core team disclosed seven vulnerabilities in Ruby's regular expression engine and string case conversion, and released Ruby 4.0.10, 3.4.13 and 3.3.14 to fix them.
  • Most of the flaws do not have CVE identifiers yet. The first to receive one is CVE-2026-132825, a one-byte heap overflow in string case conversion that researchers at Veria Labs have named Ruby2Shell.
  • Ruby's maintainers say they are aware of proofs of concept showing that some of these flaws can be used for remote code execution. Even where code execution is not reached, a crafted request can crash the Ruby process and take the application down with it.
  • Miggo has reproduced a DoS on Rails and Sinatra applications.
  • Ruby 3.2 and earlier have reached end of life and will not receive these fixes.
  • Miggo customers are receiving mitigation and remediation instructions on how to protect themselves until they can patch.
  • No exploitation in the wild has been reported as of publication.

What Are the Ruby Regexp and String Vulnerabilities?

Ruby is the language behind Ruby on Rails and behind widely deployed products such as GitLab, GitHub Enterprise Server, Mastodon and Discourse. The seven flaws sit in two parts of Ruby itself, which means every application running an affected Ruby version carries them, whatever gems it uses.

The first group is in string case conversion. When Ruby changes the case of text with methods such as upcase, swapcase, downcase(:fold) or casecmp?, it can write past the end of the memory buffer it allocated. Ruby2Shell is the clearest example. In many single-byte encodings, such as ISO-8859-1 and Windows-1252, the German letter ß has no single-character uppercase form, so Ruby writes two characters where it checked room for one. An attacker only needs to send text that the application changes the case of, a regular operation in Ruby on Rails and similar applications.

The second group is in the regular expression engine. Four of these flaws are triggered when an application compiles, matches or prints a regular expression pattern that an attacker supplied, which matters for applications that build patterns from user input, such as search and filtering features. The fifth is triggered by the text being matched rather than the pattern, and can disclose memory contents or crash the process.

Separately these vulnerabilities may be low-impact, but chained together they can form a more potent vulnerability.

What Is Public So Far

AdvisoryCVEBug typeWhat the attacker needs to controlImpact, per the Ruby advisory
GHSA-34m4-m9fh-gqp5 (Ruby2Shell)CVE-2026-132825One-byte heap buffer overflow in string case conversionText the application changes the case of, in a single-byte encodingMay allow remote code execution
GHSA-87fm-7w84-j2pxPendingInteger overflow leading to a heap buffer overflow in string case conversionText the application changes the case ofMay allow remote code execution
GHSA-7x2q-68qv-6p8xPendingDouble free in regular expression compilationA regular expression patternMay allow remote code execution in applications that compile attacker-controlled patterns
GHSA-3p8q-wmhx-vm2wPendingInteger overflow leading to a heap buffer overflow in regular expression compilationA regular expression patternMay allow remote code execution in applications that compile attacker-controlled patterns
GHSA-7whj-cfh7-xgm4PendingHeap buffer overflow in Regexp#to_sA regular expression patternMay allow information disclosure or remote code execution
GHSA-wpqw-5qxg-m68rPendingOut-of-bounds read in case-insensitive regular expression matchingA regular expression patternMay allow remote code execution in applications that use attacker-controlled patterns
GHSA-pvgc-g7gj-pv6hPendingOut-of-bounds read in case-insensitive backreference matchingThe text being matchedMay disclose memory contents or crash the process
GHSA-34m4-m9fh-gqp5 (Ruby2Shell)

CVE:
CVE-2026-132825

Bug type:
One-byte heap buffer overflow in string case conversion

What the attacker needs to control:
Text the application changes the case of, in a single-byte encoding

Impact, per the Ruby advisory:
May allow remote code execution
GHSA-87fm-7w84-j2px

CVE:
Pending

Bug type:
Integer overflow leading to a heap buffer overflow in string case conversion

What the attacker needs to control:
Text the application changes the case of

Impact, per the Ruby advisory:
May allow remote code execution
GHSA-7x2q-68qv-6p8x

CVE:
Pending

Bug type:
Double free in regular expression compilation

What the attacker needs to control:
A regular expression pattern

Impact, per the Ruby advisory:
May allow remote code execution in applications that compile attacker-controlled patterns
GHSA-3p8q-wmhx-vm2w

CVE:
Pending

Bug type:
Integer overflow leading to a heap buffer overflow in regular expression compilation

What the attacker needs to control:
A regular expression pattern

Impact, per the Ruby advisory:
May allow remote code execution in applications that compile attacker-controlled patterns
GHSA-7whj-cfh7-xgm4

CVE:
Pending

Bug type:
Heap buffer overflow in Regexp#to_s

What the attacker needs to control:
A regular expression pattern

Impact, per the Ruby advisory:
May allow information disclosure or remote code execution
GHSA-wpqw-5qxg-m68r

CVE:
Pending

Bug type:
Out-of-bounds read in case-insensitive regular expression matching

What the attacker needs to control:
A regular expression pattern

Impact, per the Ruby advisory:
May allow remote code execution in applications that use attacker-controlled patterns
GHSA-pvgc-g7gj-pv6h

CVE:
Pending

Bug type:
Out-of-bounds read in case-insensitive backreference matching

What the attacker needs to control:
The text being matched

Impact, per the Ruby advisory:
May disclose memory contents or crash the process
DetailStatus
Affected Ruby versions4.0.0 through 4.0.9, 3.4.0 through 3.4.12, and 3.3.13 and earlier
Fixed Ruby versions4.0.10, 3.4.13 and 3.3.14
End-of-life versionsRuby 3.2 and earlier will not receive fixes
SeverityCVE-2026-132825 is rated 7.4 (High). The other six are awaiting CVE assignment and scoring.
Authentication requiredCVE-2026-132825 in most configurations is pre-auth and pre-filtering. Other vulnerabilities are dependent on application code.
Exploitation in the wildNo reports as of November 19, 2026, 10:49 IST
PatchRuby security release, November 18, 2026. Linux distribution packages, official container images and vendor products that bundle Ruby will follow on their own schedules.
Affected Ruby versions:
4.0.0 through 4.0.9, 3.4.0 through 3.4.12, and 3.3.13 and earlier

Fixed Ruby versions:
4.0.10, 3.4.13 and 3.3.14

End-of-life versions:
Ruby 3.2 and earlier will not receive fixes

Severity:
CVE-2026-132825 is rated 7.4 (High). The other six are awaiting CVE assignment and scoring.

Authentication required:
CVE-2026-132825 in most configurations is pre-auth and pre-filtering. Other vulnerabilities are dependent on application code.

Exploitation in the wild:
No reports as of November 19, 2026, 10:49 IST

Patch:
Ruby security release, November 18, 2026. Linux distribution packages, official container images and vendor products that bundle Ruby will follow on their own schedules.

We will add more technical details to this page as they are published.

Which of Your Applications Are Actually Exposed?

Knowing that you run Ruby is not enough to plan a response. Three questions decide whether a given application is at risk: whether the running process uses an affected Ruby version, whether attackers can reach it, and whether attacker input actually reaches the vulnerable code. For the case conversion flaws, that means request text being upcased, downcased or compared without regard to case. For four of the regular expression flaws, it means a pattern built from user input.

Miggo answers those questions from runtime evidence. Using DeepTracing™, Miggo maps the Ruby applications that are actually running in your environment, the Ruby versions they run on and how they are exposed to the internet. Because of where these vulnerabilities live, Miggo’s profiling is used to determine exploitability and whether affected functions are running. That lets your team start the rollout with the internet-facing applications that matter most, instead of working through an inventory of every Ruby installation.

What to Do Now

  1. Find every Ruby runtime in your environment, including application servers, background workers, container base images, distribution packages and products that bundle their own Ruby, such as GitLab and GitHub Enterprise Server.
  2. Upgrade to Ruby 4.0.10, 3.4.13 or 3.3.14, rebuild the images that depend on it and install your vendors' fixed releases as soon as they are available.
  3. Restart your application processes and verify the Ruby version that the running process reports, not only the version that is installed.
  4. If you run Ruby 3.2 or earlier, plan the migration to a supported version and put a runtime mitigation in place until it is complete.
  5. Review code that builds regular expressions from user input.
  6. Watch for unexpected crashes and restarts of Ruby worker processes such as Puma, Unicorn and Sidekiq, and for requests that declare legacy character encodings such as ISO-8859-1 or Windows-1252.

Get Protected While You Patch

Miggo can show you which of your Ruby applications are exposed to Ruby2Shell and the other six Ruby flaws, and protect them while your team rolls out the fix.

If you’re concerned about these Ruby vulnerabilities, our team can help you find exposed applications and put protection in place right away. Contact us here

This page is updated on a rolling basis. Check back for new details as they become public.

Sources

<script src="https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/gsap.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/Flip.min.js"></script>

<script>
  document.addEventListener("DOMContentLoaded", (event) => {
    gsap.registerPlugin(Flip);
    const state = Flip.getState("");
    const element = document.querySelector("");
    element.classList.toggle("");
    Flip.from(state, {
      duration: 0,
      ease: "none",
      absolute: true,
    });
  });
</script>
<script src="https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/gsap.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/gsap@3.12.5/dist/Flip.min.js"></script>

<script>
  document.addEventListener("DOMContentLoaded", (event) => {
    gsap.registerPlugin(Flip);
    const state = Flip.getState("");
    const element = document.querySelector("");
    element.classList.toggle("");
    Flip.from(state, {
      duration: 0,
      ease: "none",
      absolute: true,
    });
  });
</script>
Key takeaways

Frequently Asked Questions

Heading