5 Critical Vulnerabilities Patched This Week — Is Your Stack Exposed?

In the space of roughly two weeks in late July and early August 2026, five genuinely critical, unrelated vulnerabilities landed across tools that sit at the center of how modern software actually gets built and run. CISA added an actively exploited, unauthenticated remote code execution flaw in JetBrains TeamCity (CVE-2026-63077, CVSS 9.8) to its Known Exploited Vulnerabilities catalog; Ruby on Rails patched a critical Active Storage flaw (CVE-2026-66066, CVSS 9.5) that can expose an application’s master secrets through nothing more than an image upload; Metabase disclosed a maximum-severity, unauthenticated SQL injection (CVSS 10.0) that was actively exploited against its own cloud infrastructure; and the Django Software Foundation and HashiCorp each shipped critical patches of their own, including a perfect CVSS 10.0 cross-tenant credential flaw in Terraform’s MCP Server. None of these five bugs are connected. That’s precisely the point.

At Webtoz, this kind of concentrated patch cycle is exactly what a genuine technology consultancy engagement is built to catch before it becomes an incident, closely tied to the architectural discipline behind custom software development.

This guide covers what each of these five vulnerabilities actually does, why they landed within days of each other, what they collectively reveal about where modern software supply chains are genuinely fragile, and a practical process for auditing your own stack against this specific wave and the next one that follows it.

1. Why This Week’s Patch Cycle Matters

Critical vulnerabilities get disclosed constantly, so it’s worth being precise about why this particular cluster deserves more attention than the usual weekly patch notes. Two of these five vulnerabilities carry confirmed active exploitation in the wild rather than theoretical risk, one scores a perfect 10.0 on the CVSS severity scale, and every single one of them sits in infrastructure that a huge share of modern software teams depend on daily without a second thought — CI/CD pipelines, web application frameworks, business intelligence platforms, and infrastructure-as-code tooling. This isn’t an edge-case vulnerability in a rarely used library; it’s a direct hit on the tools sitting at the center of how software actually ships.

The timing compounds the risk. When multiple critical patches land in the same short window, security and engineering teams have to triage, test, and roll out fixes across several unrelated systems simultaneously, which is exactly the kind of concentrated pressure that leads to patches getting deprioritized, delayed, or applied without adequate testing. Attackers understand this dynamic well, and the gap between disclosure and patching is precisely where most real-world exploitation actually happens.

2. The Five Vulnerabilities at a Glance

Before diving into each one individually, here’s how they compare on severity, exploitation status, and what an attacker actually gains.

3. JetBrains TeamCity: CVE-2026-63077

TeamCity is a continuous integration and delivery platform that sits at the very center of how a huge number of engineering teams build, test, and deploy their software, which makes any critical vulnerability in it a supply-chain problem, not just a single-server one. CVE-2026-63077, a deserialization of untrusted data flaw in TeamCity’s agent polling protocol, lets an unauthenticated attacker with basic HTTP or HTTPS access to a TeamCity server bypass authentication entirely and execute arbitrary operating system commands with the privileges of the TeamCity server process — no credentials and no user interaction required. JetBrains disclosed the flaw on July 27 stating it had seen no active exploitation, but CISA added it to its Known Exploited Vulnerabilities catalog on August 5, and JetBrains itself later confirmed reports of both successful attacks and attempted exploitation against unpatched servers.

A successful compromise can expose stored credentials, modify server state, and corrupt the integrity of build artifacts flowing downstream into production — exactly the kind of supply-chain attack surface that made a previous TeamCity vulnerability, exploited by a state-linked threat actor in 2023, so damaging. Organizations running affected versions should upgrade to TeamCity 2025.11.7 or 2026.1.3 immediately, or apply the available security patch plugin if an immediate full upgrade isn’t feasible.

4. Ruby on Rails Active Storage: CVE-2026-66066

This one is dangerous precisely because of how ordinary the attack surface looks on the outside — an image upload feature, something nearly every consumer-facing Rails application has somewhere. CVE-2026-66066 affects Active Storage’s default image processing when using the libvips library, allowing an unauthenticated attacker to upload a specially crafted image and read arbitrary files from the server, including the process environment that typically holds the Rails master key, database credentials, and cloud storage secrets — a chain security researchers have dubbed capable of escalating all the way to full remote code execution once those secrets are exposed. Vips has been the default Active Storage image processor since Rails 7.0, meaning any Rails 7.0 through 8.1 application that accepts untrusted image uploads is potentially in scope, without needing to explicitly enable variant generation as a separate feature.

The Rails team patched the flaw in Active Storage 7.2.3.2, 8.0.5.1, and 8.1.3.1, but patching Rails alone isn’t sufficient — libvips itself needs to be at version 8.13 or later, and applications running older Rails releases with no available upstream fix face a harder remediation path that may require a version upgrade rather than a simple patch. Given the sensitivity of what’s exposed, any team confirming they were vulnerable should treat every secret the application could read as compromised and rotate accordingly, not just apply the patch and move on.

5. Metabase: Unauthenticated SQL Injection, CVSS 10.0

Metabase is a widely deployed open-source business intelligence platform, and BI tools carry a specific kind of risk that goes beyond their own codebase — they typically hold standing, privileged credentials to every database they’re connected to. The vulnerability, tracked as GHSA-vwf4-m7j8-wcjf with a maximum CVSS score of 10.0, is an unauthenticated SQL injection reachable through the public password-reset API endpoint, letting an attacker inject arbitrary SQL, escalate to full administrator access, and from there steal the stored credentials for every connected database, reading or exporting whatever data those connections expose. Metabase confirmed its own cloud infrastructure was targeted starting around August 3, patched the flaw within hours for cloud customers, and released fixed point releases across every affected major version branch from 58 through 63.

Self-hosted Metabase instances remained exposed until manually updated, and at least one downstream customer has already confirmed a limited data exposure traced back to this exact flaw. Because compromising a single BI instance can cascade into compromising every data source it’s connected to, this is the kind of vulnerability where patching speed genuinely matters more than it does for most application-layer bugs — the blast radius extends well past the vulnerable software itself.

6. Django and Terraform MCP Server

Rounding out the week, HashiCorp and the Django Software Foundation each patched their own critical issues, both disclosed as part of the same coordinated early-August patch cycle. HashiCorp’s Terraform MCP Server carried a perfect CVSS 10.0 cross-tenant credential reuse flaw affecting deployments running in Streamable HTTP mode, where one user’s session or bearer token could be reused for a subsequent, different user’s requests — a serious issue for any team running a shared Terraform MCP server rather than a single-user local instance. Django’s fixes, released in versions 6.0.8 and 5.2.17, addressed a documented admin-panel attack path that requires a staff account with view permission on a model containing a spatial field, making it more narrowly scoped than the TeamCity or Metabase flaws but still worth patching promptly on any Django deployment using GIS features.

None of the eleven CVEs disclosed across this particular Veeam, HashiCorp, and Django patch cycle had confirmed active exploitation or public proof-of-concept code at the time of disclosure, which is a meaningfully different risk profile from TeamCity and Metabase. That distinction matters for prioritization — it doesn’t mean these patches can wait indefinitely, but it does mean they belong slightly further down the queue than vulnerabilities already being actively exploited in the wild.

7. What These Five Have in Common

On the surface, a CI/CD platform, a Ruby framework, a BI tool, an infrastructure-as-code server, and a Python framework have almost nothing to do with each other. What they share is structural: every one of them is infrastructure that sits behind the scenes of a much larger system, trusted implicitly by everything built on top of it, which means a single flaw in any of them doesn’t just compromise that one tool — it compromises everything the tool has privileged access to, whether that’s build artifacts, application secrets, connected databases, or cloud infrastructure state. This is the defining shape of modern software supply-chain risk, and it’s exactly why a genuine architecture and security audit needs to look past the application layer and examine what every piece of supporting infrastructure is trusted to touch.

8. Common Mistakes

These mistakes recur across nearly every concentrated critical-patch cycle, not just this particular week’s batch.

• Patching the application but not its dependencies: Updating Rails without confirming libvips is also on a fixed version.
• Treating “no exploitation confirmed yet” as “not urgent”: A critical CVSS score is a real risk regardless of whether exploitation has been publicly confirmed.
• Patching without rotating exposed secrets: Applying the fix but leaving credentials the flaw could have exposed unchanged.
• Assuming self-hosted tools inherit vendor cloud patches automatically: Cloud instances often get fixed first, leaving self-hosted deployments exposed for days or weeks longer.
• No inventory of what infrastructure tools are actually running: Teams can’t patch what they don’t know they’re exposed to.
• Deprioritizing infrastructure tooling behind application-layer work: Treating CI/CD and BI platforms as lower-priority than customer-facing code, despite their privileged access.

9. Final Thoughts: Patching Is a Queue, Not an Event

Five unrelated critical vulnerabilities landing within roughly two weeks isn’t actually an unusual anomaly — it’s a fairly accurate picture of how often this happens across the modern software supply chain, most weeks simply don’t get this much simultaneous attention. The teams that handle weeks like this well aren’t the ones scrambling reactively when a headline appears — they’re the ones with an existing inventory of their infrastructure, a standing patch review cadence, and an architecture where a single compromised tool doesn’t automatically mean every connected system is exposed too. That’s a design discipline question as much as a patching one, and it’s worth building before the next concentrated wave arrives, not during it.

Not sure whether your stack carries hidden exposure like this? Explore our technology consultancy services, review our pricing, or contact us for an architecture and security audit of your current stack.