Multiple vulnerabilities in Regexp and String case conversion
Ruby maintainers released versions 4.0.10, 3.4.13, and 3.3.14 to resolve seven vulnerabilities across regular expressions and string case conversion routines.
By Dillip Chowdary • Nov 19, 2026 • Source: ruby-lang.org

At a glance
- Product
- Ruby programming language
- Patched versions
- Ruby 4.0.10, 3.4.13, and 3.3.14
- Release date
- 18 Nov 2026
- Vulnerability scope
- Seven security advisories
- Severity impact
- Remote code execution and memory corruption
- Maintenance limit
- Ruby 3.2 and earlier will not receive fixes
In this post
The Ruby development team released emergency security updates across three supported release series to resolve seven vulnerabilities discovered in the regular expression engine and string case conversion routines. According to ruby-lang.org's report, several of these flaws have working proof-of-concept exploits demonstrating remote code execution. Maintainers published Ruby 4.0.10, 3.4.13, and 3.3.14 to close the attack surfaces across production deployments.
This report details the technical breakdown of all seven security advisories, the proof-of-concept exploit vectors, and the maintenance boundaries across affected branches. It is written for systems administrators and Ruby software developers who manage production runtime deployments. Readers will find exact advisory identifiers, vulnerable version thresholds, and the upgrade status governing current and deprecated releases.
01Heap corruption in string case conversion
The string case conversion system contains two distinct memory corruption defects capable of triggering heap-level manipulation during normal string alterations. Under advisory GHSA-34m4-m9fh-gqp5, altering the character casing of a crafted string triggers a one-byte heap-based buffer overflow. The maintainers confirmed that existing proof-of-concept exploits prove this flaw can trigger remote code execution.
A second vulnerability tracked under GHSA-87fm-7w84-j2px involves an integer overflow condition inside the string case conversion routines that precipitates a heap-based buffer overflow. Modifying the case of a crafted string causes an arithmetic calculation error, leading to uncontrolled heap memory writes. Verified proof-of-concept exploits confirm that attackers can manipulate this flaw to trigger remote code execution.
Security researcher Stephan Lipp from Ada Logics alongside Anthropic discovered the one-byte heap buffer overflow flaw in string case conversion. The separate integer overflow vulnerability leading to heap buffer corruption was identified and reported by researcher babayaga. Both flaws affect standard string case conversions operating on untrusted text without requiring custom regular expression engines.
02Double free and compilation integer overflows
The regular expression engine contains two critical compilation vulnerabilities that impact systems processing dynamic, user-controlled search patterns. Tracked as GHSA-7x2q-68qv-6p8x, the first vulnerability involves a double-free defect inside regular expression compilation. Compiling a crafted regular expression pattern may allow remote code execution, and verified proof-of-concept exploits confirm this flaw can trigger code execution.
Under advisory GHSA-3p8q-wmhx-vm2w, an integer overflow flaw inside the regular expression engine compilation logic causes an adjacent heap buffer overflow. Applications that compile attacker-controlled regular expression patterns face the risk of arbitrary remote code execution. Security maintainers noted working proof-of-concept exploits showing that this compilation heap overflow can be used to execute code.
Stephan Lipp from Ada Logics and Anthropic identified the double-free compilation defect during their vulnerability analysis of the Ruby runtime. The compilation integer overflow flaw under GHSA-3p8q-wmhx-vm2w was separately discovered and credited to security researcher aphantom. Both vulnerabilities present immediate operational hazards for web services accepting regular expression syntax from external clients.
03Out of bounds reads during matching
Advertisement
Tech Pulse Daily
Get tomorrow's pulse first
Join engineers who read Tech Pulse before stand-up. Free, weekday mornings.
Beyond compilation errors, pattern execution logic inside the regular expression engine contains a serious memory defect cataloged under GHSA-wpqw-5qxg-m68r. When an application runs case-insensitive matching against a crafted regular expression pattern, an out-of-bounds read occurs. Verified proof-of-concept exploits prove this flaw can lead to attacker-controlled memory corruption and potential remote code execution.
Stephan Lipp from Ada Logics and Anthropic discovered and reported this case-insensitive matching out-of-bounds read vulnerability. Systems that evaluate dynamic filters or regular expression rules against incoming requests face exploitation if patterns originate from unverified sources. The defect permits an attacker to corrupt memory boundaries in a controllable fashion.
While common CVE identifiers have been officially requested for all seven flaws, numbering authorities have not yet assigned formal CVE numbers. The project published the disclosures using GitHub Security Advisory identifiers so downstream distributors can track fixes immediately. Administrators auditing infrastructure must cross-reference these GHSA records within vulnerability management tools until databases assign final numbers.
04Regexp string serialization and backreference leaks
Converting compiled regular expressions into string format exposes an additional memory vulnerability designated as GHSA-7whj-cfh7-xgm4. The Regexp#to_s method suffers from a heap-based buffer overflow whenever it serializes a crafted regular expression pattern. Proof-of-concept exploits prove this flaw can be exploited for information disclosure or remote code execution in programs compiling untrusted patterns.
A separate pattern matching defect documented under GHSA-pvgc-g7gj-pv6h causes an out-of-bounds read during case-insensitive backreference matching. Matching a crafted string against a backreference pattern permits unauthorized reads beyond designated buffer boundaries. This flaw allows an attacker to disclose process memory contents or force an unexpected application crash.
The serialization heap buffer overflow in Regexp#to_s was discovered by Stephan Lipp of Ada Logics and Anthropic. The backreference out-of-bounds read issue was credited jointly to security researchers Hiroya Fujinami and Hiroshi Shibata. Applications that log string representations of expressions or handle backreferenced matching logic require updated runtimes to prevent data leakage.
05Patch releases and legacy maintenance boundaries
The Ruby development team published three simultaneous maintenance releases on 18 Nov 2026 to resolve all seven advisories across supported branches. Release manager k0kubun published Ruby 4.0.10, nagachika released Ruby 3.4.13, and hsbt delivered Ruby 3.3.14. These security updates follow the earlier Ruby 3.3.13 maintenance release that was shipped by hsbt on 23 Oct 2026.
The reported flaws affect all installations running Ruby 4.0.0 through 4.0.9, Ruby 3.4.0 through 3.4.12, and Ruby 3.3.13 and earlier versions. Maintainers strongly recommend that operators upgrade immediately to Ruby 4.0.10, 3.4.13, or 3.3.14 to close exposure. Applying these updates removes the vulnerable regular expression compilation routines and string case conversion logic.
Note: Ruby 3.3 currently remains in the security maintenance phase and received the 3.3.14 update. Ruby 3.2 and all earlier releases have reached their official end of life, which means they will not receive security patches for these vulnerabilities. Environments running deprecated releases must upgrade to a supported branch to secure systems against potential exploit activity.
Frequently asked questions
Which Ruby releases contain fixes for the reported vulnerabilities?
Upgrading to Ruby 4.0.10, Ruby 3.4.13, or Ruby 3.3.14 resolves the regular expression and string case conversion vulnerabilities.
Can these vulnerabilities lead to remote code execution?
The Ruby security team confirmed proof-of-concept exploits that prove several of these vulnerabilities can trigger remote code execution in scenarios where attacker-controlled input is processed.
Will Ruby 3.2 receive security updates for these flaws?
Ruby 3.2 and earlier releases have reached end of life and will not receive security fixes.
Why are CVE numbers missing from the security advisories?
Common Vulnerability and Exposures identifiers have been requested but not yet assigned, so maintainers published the advisories under GitHub Security Advisory identifiers.
Sources
Author
Dillip Chowdary
Writes Tech Bytes coverage of AI, engineering, and the tools that actually ship. Editor of Tech Pulse Daily.
Related on Tech Bytes
Advertisement