Security researchers at Veria Labs published a flaw this week in Ruby, the programming language behind a large share of booking systems, customer portals, internal tools and custom web apps. The short version: on a default Ruby on Rails install running an affected version of Ruby, an attacker can reach the bug over the network without logging in. No account. No password. No stolen credentials.
You do not need to understand how it works. You need to know three things by tomorrow: whether your app runs on Ruby, whether it has been patched, and whose job it was to patch it. The third question is the one that will take the longest, and it is the one worth fixing permanently.
What the flaw is, in plain terms
Ruby has a function that converts text to uppercase. Boring, ubiquitous, used everywhere. According to the Ruby2Shell write-up from Veria Labs, when it encounters the German character ß in certain older text encodings, it expands it to "SS", two characters where one was expected. The code only checked that there was room for one. Feed it enough of those characters and it writes a single byte past the end of its allotted memory.
One byte. That sounds trivial. In practice, a single byte written into the wrong place is the kind of foothold that gets chained into running arbitrary commands on the server, which is why Veria Labs rate the severity as critical and describe it as reachable with network access and no authentication.
The practical facts for a business owner:
- Fixed Ruby versions are 3.3.14, 3.4.13 and 4.0.10. Anything below those in the 3.3, 3.4 and 4.0 series is affected.
- Ruby 3.2 and older are affected all the way back to 2.4.0 and are end of life, meaning there is no patch coming. If your app is on one of those, the fix is an upgrade project, not a patch.
- Rails is affected in its default configuration. So is classic-style Sinatra. Plain Rack and other frameworks are not exposed by default, though Veria Labs note that application code handling legacy encodings may still be vulnerable.
- Veria Labs say they will publish a proof of concept about a week after disclosure, to give people time to upgrade. That gives you a deadline, roughly the end of November.
The advisory is tracked as GHSA-34m4-m9fh-gqp5, with a CVE pending. That reference is worth pasting straight into your email.
Plenty of Melbourne businesses run Rails and have no idea
Rails is not a niche. It is what a great many agencies and freelancers reached for when building custom web applications over the last fifteen years. If someone built you a booking system, a membership portal, a quoting tool, a trade job-tracker or a customer dashboard between roughly 2010 and now, there is a reasonable chance it is a Rails app. Nobody told you, because it never mattered before.
It is not only bespoke work. Veria Labs list widely used self-hosted products that bundle an affected Ruby, including GitLab 19.6.0, GitHub Enterprise Server 3.22.5 and Chatwoot 4.20.0. They also list products whose latest versions already ship a fixed Ruby, including Mastodon, OpenProject and the Discourse base image. If you run any of this on your own server, in your own office or in your own cloud account, the vendor's update is on you to install.
The technical fix is easy. The accountability gap is not
Upgrading Ruby on a well-maintained application is usually a modest job. A developer who already has your deployment set up might do it in an afternoon, test included.
The pain is almost never the patch. It is the sequence that follows: you email the agency that built the thing four years ago, the developer who did the work has left, nobody has deployed to that server since 2023, the deployment credentials are in a password manager belonging to a contractor you no longer pay, and the app is running a Ruby version that is already end of life so the "patch" turns into a migration quoted at five figures.
That is the real risk this week exposes, and it has nothing to do with ß characters. It is that a lot of custom software is in a state where nobody has clearly agreed to be responsible for keeping it current. Most build agreements cover delivery. Far fewer say, in writing, who applies security updates, how quickly, and what happens if they do not.
If your answer to "who patches this" is a name rather than a contract, you do not have an arrangement. You have a habit, and habits end when people change jobs.
The sceptics have a point, and it does not change what you do
The Hacker News thread on Ruby2Shell is worth skimming if you want a sense of how working engineers are reading it. Several commenters pushed back. One asked whether an attacker can actually get Rails to process the legacy text encodings the bug needs, given modern apps are usually UTF-8 throughout. Another said that turning a one-byte overflow into full remote code execution is achievable but genuinely difficult, and wanted to see it demonstrated. One flatly dismissed the disclosure for shipping without a proof of concept. Another commenter pointed out that the flaw is already covered by a broader Ruby advisory covering six other vulnerabilities disclosed at the same time.
Take all of that as fair scepticism from people who will be doing the upgrades. It still does not change your decision. The patch exists, it is cheap, and the proof of concept is scheduled for public release within days. Waiting to find out whether the exploit is hard only makes sense if patching is expensive, and here it is not. And that last point, about six other vulnerabilities in the same advisory, is an argument for upgrading sooner rather than later, not later.
How we think about this on builds
Our view as a studio is that the maintenance arrangement should be decided before the build starts, not discovered during an incident. That means naming the language and framework versions in the handover documentation so the owner can answer "what does this run on" without ringing anyone. It means the client holding their own hosting, domain and repository accounts rather than the agency holding them. And it means a written line about security updates: who watches for them, how fast critical ones get applied, and what it costs.
None of that is exotic. It is the difference between a twenty-minute response to a week like this one and a fortnight of archaeology.
What to do before the end of the week
Send one email today to whoever maintains your web application. Ask exactly this:
- Does our application run on Ruby or Rails? If yes, which Ruby version is in production right now?
- Is it on 3.3.14, 3.4.13 or 4.0.10 or later? If not, when will it be, and reference GHSA-34m4-m9fh-gqp5.
- If we are on Ruby 3.2 or older, what is the plan and the cost, given those versions will not receive a fix?
- Do we self-host GitLab, Chatwoot or any similar tool? If so, are those on the vendor's fixed releases?
- Separately from this issue: who is contractually responsible for applying security patches to our systems, and what is the agreed response time?
Questions one through four should come back within a day. Question five is the one to watch. If the answer is vague, hedged, or "we usually get to it", that is your actual finding this week. Fix it with a written maintenance agreement while the urgency is still fresh, because the next advisory will arrive on a week when you are busier than this one.


