Metabase - The Reporting Tool That Held Every Key, and the Five Companies That Found Out
25 minAudio
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! A deep-dive on CVE-2026-72898, the unauthenticated SQL injection zero-day exploited against Metabase Cloud in early August 2026. Two corrections to our roundup of 17 August, made on air. A CVE has since been assigned - CVE-2026-72898, added to CISA's Known Exploited Vulnerabilities catalogue on 11 August and rated 10.0 under both CVSS v3.1 and v4.0. And LexisNexis has explicitly ruled out any connection between its service outage and this flaw: the similarly-named Nexis Metabase API is an unrelated product, and LexisNexis is not a Metabase Cloud customer. The timeline. 2 Aug: attacker active in Kilo Code's instance for about four hours. 3 Aug: broader attack on Metabase Cloud; Metabase detects, blocks and patches the same day. 6 Aug: public advisory; Framework notified, and notifies its own customers. 8 Aug: a researcher publishes a proof-of-concept lab. 10 Aug: CVE assigned; public exploits go open-source; Checkly and Wiz publish. 11 Aug: added to CISA KEV with a 14 August deadline; a second Metabase advisory covers further flaws; ShinyHunters lists Metabase on its leak site. The vulnerability. An unauthenticated POST to /api/session/reset_password. Four individually correct behaviours chain together: Clojure's merge not stripping attacker-supplied keys when authentication fails; JSON keywordisation; HoneySQL's raw keyword, a deliberate feature that bypasses parameterisation; and a lookup that compiles the result into unparameterised SQL. The result is blind SQL injection against the application database, leading to a forged administrator session. As Checkly put it, no password was stolen. The patch is a three-line type check. Exposure. Dataminr's 8 August scan found roughly 11,000 probable self-hosted instances, 4,309 likely vulnerable, and over 97% of fingerprinted hosts on an affected branch unpatched. Five victims disclosed, all Metabase Cloud tenants, all of whom published their own post-mortems: Framework Computer (names, emails, login IPs, addresses, phone numbers; VAT and EIN for business customers), Tally (emails and hashed passwords), n8n (136 records, plus a separately-discovered 2023 plaintext password bug), Kilo Code and Anaconda (names, emails, billing addresses, user prompts, later Slack access tokens), and Checkly (26 minutes of read-only warehouse queries exposing plaintext credentials hard-coded into check configurations). Metabase has never said how many tenants were affected. Attribution: unconfirmed. ShinyHunters listed Metabase on 11 August, but Dataminr assessed the listing as a placeholder with no scope named. Metabase has named nobody. Treat it as a claim. Check your own instance. In application or ingress logs, look for a POST to /api/session/reset_password returning HTTP 400 immediately followed by a GET to /api/user/current returning HTTP 200. That pattern indicates likely compromise. Five lessons. One: your BI tool is a production system holding a key ring - audit what it stores and scope those service accounts to read-only. Two: internet-facing auth endpoints on internal tools are an unforced error. Three: using the managed version is not the same as not being affected. Four: rotate sessions and downstream credentials, not just passwords - there was no malware, and both survive a patch. Five: use the secrets store, not free-text config fields. Visit www.kinsoft.com.au to talk through your security and IT needs. Sources: NVD and CVE.org; CISA KEV; Metabase advisories GHSA-vwf4-m7j8-wcjf and GHSA-r495-55cx-fjh7; Wiz; Bishop Fox; Dataminr; BleepingComputer; and disclosures by Checkly, n8n, Kilo Code, Framework and Tally.
Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.
Transcript
From the show. Tap a time to play from there.
I want you to just imagine a scenario on your own network right now. Like really picture your company's data infrastructure. Okay, yeah. If you had to guess the most catastrophic threat to that environment. I mean, your mind probably jumps to a sophisticated, you know, multistage ransomware attack targeting the core databases. For sure. You're looking at the big target. Exactly. You're likely not losing sleep over the quiet internal analytics dashboard to sitting on a random server in the corner. I mean, you probably
don't even classify that reporting tool as a production system. Right. And it's a massive blind spot for most engineering teams. We are. Well, we're fundamentally conditioned to armor the front door. We lock down the primary databases. We scrutinize internet -facing apps. Yeah. But internal BI tools, you know, business intelligence, they're almost always treated as read -only conveniences. They just generate charts. They aren't supposed to be threat vectors. But that assumption is exactly what we are tearing down today. So our mission for this deep dive is to unpack an incredibly
revealing transcript from Tech Talks with Kinsoft. They did this massive postmortem on the recent Metabase zero -day vulnerability. Officially tracked as CVE -2026 -72898. Right. And our goal isn't just to do some forensic play -by -play. We really want to understand the architectural philosophy, the underlying way we build software today that allowed a literal 10 out of 10 severity breach. to just hide completely in plain sight. Yeah. And to give some context on how chaotic this actually was, the source material opens
with some rapid fire corrections just because the facts on the ground were shifting. hourly. It was moving so fast. It really was. Initially, the vendor issued an advisory with no CVE attached and the severity score was entirely self -reported. Right. Which, I mean, it completely undersold the danger for a few days. Oh, absolutely. But now it is an official 10 out of 10 on both the CVSS 3 .1 and 4 .0 scales. And it immediately triggered a cease or remediation deadline. Which is huge. Yeah. Also, just as a quick, aside from the source, to clear up some industry confusion.
Yeah. LexisNexis happens to have a completely unrelated product also called Metabase. Right. There is no connection whatsoever. We're talking strictly about the BI platform based in San Francisco. And that BI platform is exactly where we have to start because the core danger here, it isn't just that the application got compromised. uses this fantastic analogy, actually. They say Metabase doesn't just hold your data, it holds the way in. It's the key ring. Precisely. It is the key ring. I mean, to generate those pretty graphs
for the sales team, Metabase needs connection strings, credentials, API tokens, basically for every single data warehouse, Snowflake instance, and Postgres database you pointed at. Wow, yeah. So if an attacker breaches the web server hosting your blog, they own the blog. But if they breach Metabase, they don't just own the dashboard, they... Deal the master key ring that unlocks every single core data repository connected to it. Which really puts the scale of this exposure into perspective. Because Metabase isn't some
niche tool, right? They claim over 100 ,000 organizations use their platform across 150 countries. It's everywhere. It is. They're deeply embedded in the infrastructure of massive financial and tech companies. Yeah. I'm talking N26, Revolut. gojek these are heavily regulated high stakes environments and we actually have hard data on the blast radius thanks to internet wide scans run by wiz and dataman Right around August 8th. Okay, let's
unpack this. What did they find? Well, they found that roughly 13 % of all cloud environments globally were running a self -hosted instance of Metabase. 13 %? I mean, that is a staggering number. But here is the stat that actually made my jaw drop when I read the source. Wow, the exposure stat. Yes. Of those self -hosted instances, roughly a quarter were fully accessible from the public internet. Yeah, that's rough. The data men telemetry. pinpointed over 4 ,300 highly vulnerable instances just openly sitting on the web. They were touching
government networks, health care, aviation, finance. It essentially means thousands of organizations left a master key ring hanging on a hook on the outside of their building. Basically, yeah. And once attackers realized that hook was there, the timeline of exploitation compressed to an almost terrifying degree. The speed of, this is what really gets me. So August 2nd, a Sunday, is the first documented intrusion. An attacker breaches a Metabase instance owned by an AI coding company called KiloCode, and they're just poking
around for about four hours. Just scaring it out. Right. And then the very next day, August 3rd, the attacks escalate. Exponentially. They hit Metabase's own managed cloud infrastructure. Tenants like Checkly, Framework, Tally, they all get hit essentially simultaneously. But, you know, you do have to give Metabase credit where it's due here. Fair enough. On that exact same day, August 3rd. They actually detect the abnormal behavior, isolate the exploited endpoints, identify the root cause in the code, and push a patch across their entire managed cloud. Wow.
Yeah, same -day detection and remediation for cloud tenants is exceptional engineering. It is exceptional, but, well, it didn't stop the bleeding for the rest of the world. Because by Thursday, August 6th, Metabase publishes its public security update for the self -hosted community. And then the weekend hits and everything just falls apart. By August 10th and 11th, the CVE is formalized. Security researchers at WIS publish a full reverse engineering write -up. Which, ironically, inadvertently gives attackers the exact blueprint to build open source exploits.
Exactly. CISA adds it to the known exploited vulnerabilities catalog. And then this ransomware group, Shiny Hunters, they list Metabase on their extortion site. So from the first quiet intrusion on August 2nd to a fully weaponized, globally scaled export circulating on the open Internet, it was nine days. Nine days. That window for remediation, it just doesn't exist anymore. It really doesn't. And I want to dig into how this happened. Because this wasn't some, you know, standard buffer overflow or complex memory corruption. The anatomy of this 10 out of 10 flaw is honestly
kind of elegant. It really is. The entry point was a single, unauthenticated endpoint. It was a PST request to API slash session slash reset underscore password. Which, to be clear, is an endpoint deliberately designed to be accessed by people who aren't logged in. Right. Obviously. It's supposed to take two arguments, a token proving you requested a reset and your new password. So if I'm an attacker. And I intercept that request. I don't just send a token and a password. I inject an extra field. I slip a user ID into the payload.
And this is where the source completely changed my perspective on secure coding. This flaw wasn't caused by a broken piece of code. It was caused by four individually correct, highly documented software behaviors chaining together flawlessly. What's fascinating here is the concept of composition flaws. None of the four steps we are about to discuss are actually bugs. Not a single one. Not one. First, Metabase is written in Clojure. When the attacker's web request hits the backend, the system attempts to merge the incoming payload
with the result of a failed authentication check. Okay, so a standard merge. Right. And Clojure's merge function does exactly what the manual says. It combines two data maps, but crucially, it does not strip out unexpected keys. Oh, wow. So the attacker's injected user ID survives the merge simply because there was no legitimate user ID to overwrite it. I was trying to visualize this when I read it, and it feels like a data smuggling operation. It really does. It's kind of like a bouncer at a club. The attacker walks up, fails the VIP list check, but subtly hands
their VIP badge to the guy behind them, which is the payload. That's a great way to look at it. Right. The bouncer did their job by rejecting the first guy. But the club's back end system just automatically prints a wristband for whatever badge gets handed to it next. It doesn't even verify if it belongs to someone on the list. That is a highly accurate analogy because step two is the JSON parser. The payload. complete with that sum of old user id gets parsed from json into a closure map and the parser works
perfectly exactly it works perfectly keeps the malicious key now step three is where the architecture really betrays them metabase uses a sql query builder library called honey sql right honey sql has this specific keyword called raw if you pass data tagged with raw You are explicitly telling the database, do not parameterize this. Treat this as literal SQL code. Which is wild, right? I mean, parameterization is the golden rule of database security. It separates the code from the user's data so you can't run an injection
attack. Why would a developer ever include a raw bypass? Well, because developers demand flexibility. BI tools have to generate these insanely complex, highly customized queries across dozens of different database dialects. So it's a performance thing or just to make it work? Just to make it work. Yeah. Parameterization often breaks down when you're trying to dynamically construct really complex table joins on the fly. So the raw keyword was a deliberate documented feature for the developers to use when the standard engine just couldn't
handle the complexity. Wow. But the attacker leverages that feature. Yeah. And that brings us to the sync, which is the final step. Right. The system takes that smuggled user ID. Assumes it's a safe integer because, hey, it came from the password reset flow and drops it into a database lookup using that raw keyword. And suddenly the attacker is executing arbitrary, unparameterized SQL directly against Metabase's own internal application database. Incredible. And they did all of this from the password reset page without authenticating once. This is exactly why SCADA
code analysis tools completely missed this. I mean, if you run a scanner on that code, it sees the closure merge and says, yeah, valid function. Yep. the honey sql raw command and says yep known library feature the vulnerability doesn't exist in any single line of code it exists entirely in the seams between those functions it fundamentally challenges how we audit software we review components in isolation but the explosive reaction only happens when they are combined under malicious conditions and what's almost tragic about this is how simple the fix was yeah when wiz reverse
engineered the patch they found metabase fixed this 10 out of 10 vulnerability with about three lines of code. Three lines. They just added a validation check to ensure the user ID was a positive integer before letting it touch the database. Three lines to stop an internet -wide meltdown. But, you know, by the time those three lines were deployed, the attackers were already inside. Because this was a blind SQL injection into the application database, the attacker could manipulate the backend to forge a valid administrator session. Let that sink in for a second for everyone
listening. They forged an admin session without a password. They didn't phish an employee. They didn't have to intercept a multi -factor authentication prompt. They bypassed the entire authentication apparatus. They just walked right past it. Exactly. And once they had that forged session, they possessed the key ring. Which leads us directly into the fallout. The source material spends a lot of time analyzing the victim response. They specifically praise what they call the honest five. The honest five, right. Because we don't know the full count of Metabase cloud tenants that were breached,
but five companies published highly detailed, incredibly transparent postmortems of their own breaches. And you rarely see this level of honesty because, you know. Legal teams usually sanitize these disclosures into oblivion. Oh, absolutely. Checkly was one of the five. They do synthetic monitoring. They're SOC2 certified, deeply engineering focused. Yeah. And they reported that the attacker had 26 minutes of read -only query access against their connected data warehouse. But 26 minutes of read -only access to a central data warehouse is catastrophic. Yeah. Treckley admitted the
attacker pulled plaintext custom headers, hashes of OpenTelemetry API keys, and encrypted integration tokens for Slack, Vercel, and CoreLogix. Framework, the modular laptop company, was another one. They found out on August 6th that their data had been exfiltrated three days earlier. Yeah. They lost massive amounts of personally identifiable information, PII. Full names, emails, billing, and shipping addresses. The only silver lining there was that their payment processing was entirely segregated. Tally, the form builder, had a similar
exposure. They lost emails and hash passwords. At the time of the source publication, there was actually an open question regarding whether Tally's password hashes were salted. Why does that matter so much? Well, if you don't salt a hash, attackers can crack them exponentially faster using pre -computed rainbow tables. It's a huge risk. Oh, right. Then we have KiloCode, the first known victim from August 2nd. They lost PII and user prompts. But what's brutal is that three days into their incident response, they realized the attacker hadn't just queried
the database. They had extracted access tokens for KiloCode's internal Slack bot. That's terrifying. It is. They had to frantically invalidate all those tokens before the attacker pivoted into their internal communications. But the standout response here really belongs to N8N, a workflow automation company. The source rightly calls their disclosure a masterclass in forensic scoping. I loved this part. They didn't just say, oh, data was accessed. They narrowed the blast radius to exactly 136 records. But what makes their
postmortem exceptional is their technical honesty regarding non -deterministic queries. Yes. OK, so this part actually confused me initially. They explicitly stated that out of those 136 records, they couldn't be 100 % sure if 62 of them were actually accessed. Right. Why couldn't they just look at their SQL logs and see exactly what? the attacker downloaded? Because database logs generally record the question that was asked, not the answer that was given. Oh, okay. Yeah. So if an attacker injects a non -deterministic
query, like select all from users order by random limit 10, the log proves the attacker asked for 10 random users. But it doesn't log which 10 random users the database handed over. Exactly. Or if the query relied on a hyper -specific timestamp that has since passed, the defenders just cannot replicate the exact state of the database at the moment of the attack. And NAN admitted this blind spot instead of pretending they had perfect visibility. They own the ambiguity. And here's where it gets really interesting for you as a listener. While NAN was doing this incredibly
deep forensic sweep, They actually found a completely unrelated three -year -old bug. Yeah. It had already been fixed, but historically it had left 25 passwords sitting in plain text in an old table. And they disclosed it anyway. I mean, they were investigating a massive zero -day fire, stingled upon the cold ashes of a three -year -old mistake, and proactively contacted those 25 users. That is the gold standard for security culture right there. Oh, without a doubt. But stepping back, Checkly's postmortem contained
an admission that I think applies to almost everyone listening to this deep dive. When they audited the 26 minutes of queries, they realized their analytics environment simply had far more permissions and access to highly sensitive data than it actually required to build its charts. It is a massive violation of the principle of least privilege. scaled across their entire infrastructure i mean if a bi tool only exists to visualize daily sales metrics why does its database credential have the authority to pull from the hashed passwords
table exactly or they open telemetry token configuration we over permission internal tools because it's just faster for the developers now i do want to talk about how metabase handled this because the source paints a very nuanced picture of vendor responsibility here it is a fiercely debated scorecard Let's start with the commendations. Detecting an unknown zero -day intrusion on your managed cloud environment and deploying a patch globally on the exact same day is phenomenal. It really is. They also handed incredibly detailed
forensic logs directly to the victims. Checkly explicitly stated they would not have been able to scope their own breach without Metabase providing those internal logs. Right. I look at that same -day cloud patch and think, that is heroic incident response. Yeah. But then you look at the self -hosted site and it's a completely different story. There was a full three -day gap between Metabase containing the attack on their own cloud on August 3rd and issuing the public advisory on August 6th. And this is where the friction is. Metabase protected their paying cloud tenants
instantly. But by delaying the public disclosure, they left thousands of open -source, self -hosted instances completely blind on the internet. While attackers were actively hunting them. Exactly. Attackers who had already reverse -engineered the cloud patch. And the fact that they released the advisory without a CVE identifier compounded the disaster. Automated security scanners and triage dashboards, they pull from CVE databases. By not securing that CVE for nearly a business week, Metabase basically ensured that every automated
defense system on the planet was silent. The dashboards were green while the servers were burning. It really highlights the extreme tension between protecting managed infrastructure and fulfilling your obligations to the open source community. And the chaos was amplified by the attribution fog. Oh, right. Who actually executed this campaign? Well, on August 11th, a notorious ransomware syndicate called Shiny Hunters claimed responsibility by listing Metabase on their extortion site. But the source is extremely adamant on
this point. Treat that as a claim, not a verified fact. Because in threat intelligence, claims are cheap. The data miner analysis labeled the shiny hunters post as an unconfirmed placeholder. Interesting. Yeah. The listing only advertised about seven gigabytes of data and it lacked all of the descriptive metadata, sample proofs and scoop details that shiny hunters typically uses to prove they actually have the goods. It fits their operational pattern, you know, compromising a central platform to harvest data from downstream targets. But a pattern is not proof. But regardless
of who did it, there was a secondary threat that emerged in the aftermath that really unsettled me. The source code leak? Yes. Cyber news researchers were digging through the published archive dumps, and they found 174 gigabytes of source code originating from nearly 300 private database repositories. Which is arguably worse than losing the data itself. Really? How so? Well... If a company used a secrets manager, their immediate data loss might be contained. But exfiltrated source code provides an attacker with a treasure map.
They can pull that code offline, feed it into advanced static analyzers, and just spend months looking for the next composition flaw in the seams of the architecture, completely undetected. So what does this all mean for us? You know, the source crystallizes this entire disaster into five highly actionable lessons. And they aren't theoretical. These are things you need to check on Monday morning, lesson one. Treat your BI tools as production systems. You cannot view them as passive dashboards. They are the key ring. You must ruthlessly audit the service accounts connected to them. Enforce strict minimum
read -only access scoped entirely to the tables required for the specific charts being generated. Definitely. Lesson two. Hide your internal endpoints. The fact that Metabase's entire API, including the password reset endpoint, was sitting openly on port 3000 exposed to the public internet is staggering. It's an unforced architectural error. Engineers rationalize it by saying, well, our remote employees might need to reset their BI dashboard password from home. But if an application does not serve external customers, it should
never route directly to the public internet. Put it behind an identity -aware proxy or a VPN. If those 4 ,000 vulnerable instances had simply restricted port 3 ,000 to internal traffic, this exploit would have bounced harmlessly off their firewalls. Lesson three really redefines cloud security. I think. Using a managed cloud service does not make you invincible. Remember, the Metabase cloud tenants were patched perfectly on the same day. And yet Framework, Checkly, and Tally still lost their data because the exfiltration happened in the hours before the patch existed. This is
the terrifying reality of fourth -party risk. If you are a customer buying a laptop from Framework, your PII was breached. Not because Framework's engineers made a mistake. And not even because Framework's vendor messed up. But because of the vendor's vendor. Exactly. Because a vulnerability in a third -party open source library used by Framework's BI vendor was exploited. Traditional compliance audits are virtually blind to that depth of supply chain risk. Which brings us to lesson four. When a breach like this occurs,
rotating passwords is not enough. You have to rotate everything. Because the initial vector allowed the attacker to forge an active administrative session, if you apply the three -line patch, you stop new attackers from getting in. But the attacker with the forged token is already inside. Wow, so the patch doesn't kick them out. No, their session survives the software patch. You must systematically revoke all active sessions, and you have to rotate every single credential for every downstream database connected to the tool. And the source provided this incredibly elegant one -minute log check to determine if
you were hit. You basically query your web access logs. You look for a POST request to API slash session slash reset underscore password that returns an HTTP 400 failure code. Okay. If that exact request is followed immediately by a GE2 request to API slash user slash current returning an HTTP 200 success code, you've been breached. It's brilliant in its simplicity. A failed password reset instantly followed by a successful authenticated API call. It perfectly tracks the attacker failing
the token check but successfully smuggling the payload to forge the session. And finally, Lesson 5. Stop hiding secrets in plain sight. Checkly realized their most critical exposure wasn't even the core database structure. It was that their own developers and customers were typing plain text API integration tokens directly into free text configuration fields. Because it was faster than setting up the encrypted secrets manager. Human friction will always route around security. If the encrypted secret store requires five extra clicks, developers will paste the
AWS key into the description field. You have to actively scan your configuration stores for credential formats and forcefully deprecate plain text entry fields. Looking at the entirety of this incident, it is a masterclass in unintended consequences. Four perfectly documented, mathematically correct functions, a merge, a parser, a query builder, and a database lookup. No broken code. No broken code. But layered together, they forged a 10 out of 10 weapon that bypassed authentication completely. turning a read -only analytics dashboard
into a master key that gutted dozens of companies in a matter of hours. It really forces us to evolve beyond hunting for broken code and start hunting for toxic interactions between correct code. But, you know, if we are talking about evolution, there is one final, deeply unsettling detail from the source text that fundamentally indicts how the cybersecurity industry prioritizes risk. Scoring model, right? Yes. The EPSS score. the exploit prediction scoring system it is an advanced mathematical model that ingests threat intelligence and calculates the raw probability
that a specific vulnerability will actually be exploited in the wild it's the dashboard that every security operations center relies on right yeah when you have 10 000 alerts you sort by the epss score to figure out what actually needs patching today exactly but let's look at the reality of this metabase zero day we had an active 10 out of 10 severity of vulnerability. It was actively being mass scanned across the entire internet. It was actively being exploited to exfiltrate massive amounts of corporate data from high profile targets. It was officially
enshrined on CISA's known exploited vulnerabilities catalog. And throughout this entire active meltdown, the predictive EPSS score for the CVE was sitting at well under 1%. Under 1%. So the algorithm essentially told security teams that this active global fire was mathematically irrelevant. Yes. And this leaves you with an incredibly provocative question to mull over. We rely on these advanced predictive triage models to cut through the noise. But if the algorithm completely blinds us to
a 10 out of 10 active threat, because the math mathematically ranks it as low risk, are our automated prioritization tools actually creating new vulnerabilities? Wow. As the source stated so perfectly, confirmed beats predicted every time. That is heavy. If your company's security team relies on a predictive scoring dashboard to decide what gets patched today, what massive active fires are they completely ignoring right now? Simply because the algorithm assured them the probability was under 1%. It's a scary thought.
It makes you question the very foundation of how we defend our networks. And it should definitely make you rethink exactly what might be quietly sitting on port 3000 of your own infrastructure right now, holding the master key ring to your entire business. Thanks for joining us on this deep dive.
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Japanese home goods company Iris Ohyama (online store operator Iris Plaza) found a suspicious file in an external...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Australian online retailer Who Gives A Crap told customers on 7 November 2026 that their information was accessed...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Last week in tech, 7 to 14 November 2026. Microsoft's November Patch Tuesday (10 November) fixes well over a...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! Chainalysis disclosed on 30 October 2026 that an external actor using "offensive agentic techniques" accessed...
Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! NSW Health reported unauthorised access to its Oral Health Fee For Service Scheme website on 29 October 2026;...