Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

Tech Talks With Kinsoft

Tech Talks With Kinsoft artwork

JetBrains - The Patch They Wrote, the Server They Missed, and the Backup From 2024

Sep 17, 202622 minAudio

Got something to say to this podcast? Send a voicemail, and you might hear yourself on the next episode! JetBrains has disclosed that attackers breached Cadence - its PyCharm-integrated cloud compute service - through one of its own unpatched TeamCity servers, using a vulnerability in a JetBrains product that JetBrains had already patched and publicly warned about. What Cadence is: a JetBrains-hosted service that integrates with PyCharm through an optional plugin and lets users run their projects on cloud compute resources. Cadence uses TeamCity to orchestrate that work. The flaw: CVE-2026-63077 in TeamCity On-Premises, unauthenticated remote code execution via the agent polling protocol, allowing an attacker to bypass authentication checks and execute arbitrary operating system commands. CVSS v3.1 base score 9.8, as assigned by JetBrains in the CVE record. Fixed in 2025.11.7 and 2026.1.3. Timeline. 27 July 2026: JetBrains publishes the advisory and fixed versions. 5 Aug: CISA adds it to the Known Exploited Vulnerabilities catalogue. 7 Aug: JetBrains publishes a second post warning of active exploitation in the wild. 8 Aug: attackers access JetBrains' own Cadence environment through an unpatched TeamCity server - twelve days after the patch shipped, and one day after JetBrains' own exploitation warning. 23 Aug: JetBrains discovers the exploitation. 24 Aug: the affected server is taken offline, closing the stated affected period of 8 to 24 August. 28 Aug: public disclosure; the investigation concluded on 3 September. Not an orphaned server. The exploited host was the production API server for Cadence - a live, customer-facing service. JetBrains' explanation: "The server should have been patched as part of our response to the vulnerability, but it was not." What was accessed: usernames, real names, email addresses, last login timestamps and last accessed IP addresses; a full 2024 backup of the Cadence server containing credentials, configuration, artifacts and logs; multiple AWS IAM users and secrets, including IAM users belonging to JetBrains employees; and files in S3 buckets within JetBrains AWS accounts. JetBrains states the attacker "may have accessed source code synchronized from PyCharm projects" - flagged as unconfirmed. In its 3 September update, JetBrains confirmed the actor obtained access that could have reached storage containing data associated with current Cadence users, including email addresses, project source code and credentials. No affected-user count has been published, and no threat actor has claimed the intrusion. Remediation guidance, in JetBrains' words: "Revoke and rotate all credentials and secrets that may have been used to run Cadence executions." And: "Treat all executions, including their inputs and outputs in your Cadence project, as potentially untrusted." Three things to take from it. First, treat your build system as production infrastructure - it holds deployment credentials and runs code automatically; put the console behind a VPN or IP allowlist. Second, inventory your long-lived secrets and give them an expiry: static AWS IAM keys work from anywhere, generate no login alert, and keep working until rotated - and a key frozen in a two-year-old backup has had two years to be forgotten. Third, patching is a delivery, not a decision. JetBrains decided to patch, announced it and warned the world, and the remediation still did not reach one production server. Close the ticket when you can produce a verified version number for every affected instance, not when the patch is approved. Visit www.kinsoft.com.au to talk through your security and IT needs. Sources: JetBrains Cadence security incident disclosure (28 August 2026, updated 3 September); JetBrains TeamCity advisory for CVE-2026-63077 (27 July 2026) and active-exploitation notice (7 August 2026); CISA KEV catalogue.

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.

You know, when we think about security, whether it's our physical homes or our digital lives, we usually operate under this assumption that knowledge equals protection. Right. Like imagine you are the person who literally designed the world's most advanced impenetrable burglar alarm system. Okay, I'm picturing it. You know, every wire, every sensor, every single line of code. You could probably dismantle the thing blindfolded if you had to. Oh, absolutely. So you'd logically

be the safest person on the block, right? Yeah, I mean, it's a comforting thought, assuming that writing the rulebook on security makes you immune to the threats outside. You know all the vulnerabilities. You wrote the manual on how to defeat them, so your own perimeter must be flawless. Exactly. But what if that same master alarm designer gets robbed? And we aren't talking about a scenario where like some criminal mastermind invented a magical new lockpick that defied the wells of physics. The designer just forgot to lock their own front door before going to bed. It's

the ultimate irony. And honestly, it highlights a massive blind spot we all seem to share, especially in enterprise technology. Oh, for sure. It's that perilous gap between knowing exactly how to fix a critical vulnerability and the physical operational reality of actually deploying that fix. Yeah, and that is exactly the highly uncomfortable reality we are getting into today. So welcome to the deep dive. Glad to be here. We are working from a really detailed transcript from Tech Talks with Kinsoft today, and it breaks down a very

recent, very wild security incident. It is quite the story. Right. And our goal here, whether you manage massive cloud infrastructure or you're just simply fascinated by how complex systems inevitably fail, is to explore a scenario where knowing about a threat. And even writing the software patch to fix it yourself does not automatically keep you safe. Yeah. Okay, let's unpack this. We really need to look way beyond the sensational headlines for this one. Because the mechanics of this breach, they are fundamentally different from the standard data leaks we hear about. every

other week right this isn't just a database getting dumped no not at all this isn't a story about lost passwords or a naive phishing click it's about the integrity of the core tools that the entire world uses to build software which is terrifying the company at the center of this is jet brains yes and if you aren't a software developer that name might not ring a bell but JetBrains is an absolute titan in the software world. I mean, they make the tools that professional developers practically live inside all day long.

Right. Tools like IntelliJ IDEA, PyCharm, WebStorm. The big ones. Exactly. These are integrated development environments or IDEs. They're basically the digital workbenches where modern software gets coded. Gotcha. But the critical piece of the puzzle here is another hugely popular product they make called TeamCity. Okay, TeamCity. Right. TeamCity is a continuous integration and build server. Okay, let me make sure I have the mechanics of that right. Basically, TeamCity is the automated engine that takes a developer's raw code, runs all the automated tests against it, compiled

it, and then packages it up so it can be deployed to the real world. That's a perfect summary, actually. Think of it as the central assembly line of a software factory. Okay, the assembly line, I like that. Yeah, and because it has to pull code, build it, and push it to production servers, TeamCity inherently requires massive amounts of access. It holds high -level credentials to do its job. So it's very powerful. Very. Now keep that assembly line metaphor in mind. JetBrains also runs a cloud compute service called Cadence. Right. And Cadence integrates directly with PyCharm.

So a developer working on a laptop can hand a heavy data workload off to Cadence, and it runs it remotely in the cloud. Super convenient. It is. But here is the linchpin of the whole incident. JetBrains built Cadence using TeamCity as its underlying orchestration engine. Oh, wow. So the master locksmith is using their own lock on their own front door. Exactly. JetBrains is relying on their own continuous integration tool to run a live customer -facing cloud service. Which naturally brings us to the vulnerability itself. So the flaw was cataloged as CVE -2026

-63077. A catchy name. Right. Rolls right off the tongue. And this was found specifically in TeamCity on -premises. Now, the Kinsoft transcript mentions the CISI description, calling it a, quote, deserialization of untrusted data flaw. Yes. I feel like we need to slow down and translate what that actually means on a mechanical level for those of us who don't speak CVE. Absolutely. So in computing, serialization. is the process of taking a complex, multidimensional piece of data like, say, a complete user profile with

permissions, settings, avatars, all that. Okay. And packing it down into a flat, linear format. You do this so you can easily send it over a network or save it to a disk. Makes sense. And deserialization is simply the reverse. the receiving server takes that flat package and unpacks it back into a complex, executable object in its own memory. Oh, I see. So it's like receiving a flat -packed piece of furniture in the mail. Exactly. And an untrusted data flaw means the server isn't properly checking the contents before it just starts assembling whatever is in the box. Precisely. Which means an attacker can send

a malicious package. Yeah. When the server automatically unpacks it, It isn't assembling a BIP shelf. It's assembling a piece of malware or a command to hand over control of the server. It's like opening the Flatpak box and a swarm of angry bees just flies out because you blindly assumed it was a bookshelf based on the shipping label. A very, very aggressive swarm of bees in this case. Wow. Yeah, JetBrains described the flaw as allowing an attacker to bypass authentication entirely and execute arbitrary operating system

commands. Wait, bypass entirely? entirely that is unauthenticated remote code execution. The attacker doesn't need to steal a password. They don't need a valid account. They just walk right in. They just send the malicious package and the server blindly executes their commands at the highest privilege level. OK, no wonder it received a 9 .8 out of 10 on the CVSS severity scale. I mean, that is a siren blaring red alert kind of score. 9 .8 basically means the front door is missing entirely. The vulnerability is highly exploitable over the public Internet. It requires very little technical complexity

to pull off. And the impact is total catastrophic compromise of the host system. Which makes the timeline of this incident completely wild to me. Oh, the timeline is, yeah, it's something else. Let's map out this very bad month. So on July 27th, JetBrains publishes the advisory about the flaw. They're the ones who found it, or at least patched it, and they release that patch to the public. Right. They followed standard responsible disclosure. They identified a massive hole in their flagship product, engineered the

fix, and broadcasted the solution to their user base. Okay, then the U .S. government gets involved. On August 5th, CISA adds this specific vulnerability to their known exploited vulnerabilities catalog. The KEV list, yeah. And they set a federal remediation deadline for three days later. Then, on August 7th, JetBrains publishes a second urgent warning to their customers. This flaw is now being actively exploited in the wild. Update immediately. And then, and this is a kicker, the very next day.

August 8th, attackers successfully breach JetBrains' own cadence environment using that exact vulnerability. Wait, I have to stop you there. Yeah? I am struggling to understand how this is physically possible. They got hacked the very next day after their own urgent all -caps warning. Yep. Twelve days after they themselves released the patch. I mean, if a company like JetBrains misses this, was it just some shadow IT situation? What do you mean? Like a dusty, forgotten server sitting in a basement closet that the security team didn't

even know existed. Right, yeah. What's fascinating here is the tempting narrative is always to blame the forgotten server. Right, because it makes us feel better. Exactly. It treats the breach as a rare edge case. Oh, we'd never do that. We track our main servers. But the forensics completely debunk that myth. Really? Yeah. JetBrains named the specific host that was compromised, and it was the production API server for Cadence. You're kidding. A live, customer -facing server. The main stage of their cloud offering. What? When JetBrains released their timeline, they

included this chillingly blunt sentence. They stated, quote, the server should have been patched as part of our response to the vulnerability, but it was not. Wow. Just flat out admitted it. Yeah. There was no mystery about ownership. The IT department knew the server existed. They knew it was running TeamCity. They were actively managing it. So the failure wasn't a lack of threat intelligence at all. Not at all. It was a purely operational breakdown. I mean, the remediation ticket was probably created, maybe even marked as complete.

But the actual software update simply never reached the metal of that specific machine. Exactly. Because in massive corporate environments, patching isn't just, you know, clicking update. It's a whole process. It involves. Change management boards, automated deployment scripts, coordinating maintenance windows to avoid customer downtime. Somewhere in that bureaucratic chain, the execution just failed. And attackers don't care about your internal IT friction? Nope. They just scan for open ports. Okay, so the attackers are in. They bypass authentication. They have remote code

execution on a live production server for cadence. My first instinct would be that they try to siphon off the live database. That's the classic move. Right. But the Kinsoft breakdown points out a much more insidious payload. Yeah, so once an attacker achieves remote code execution, their immediate next step is automated discovery. Like looking around the house. Exactly. And they aren't typing on a keyboard manually. They drop scripts that rapidly scour the file system for configurations, environment variables, and archives. They are

looking for peas to open other doors before they get kicked out. Precisely. And in this case, they hit the jackpot. What did they find? Among the standard usernames and IP addresses, the attackers found a full backup of the cadence server dating from 2024. Okay, an old backup. Yes. And inside that archived backup were compromised AWS IAMM users and credentials. That 2024 backup is the pivot point of the entire disaster. Okay, help me understand this. Because if someone stole a backup of my personal computer from two years

ago, I wouldn't panic immediately. Right, because things change. Yeah, I'd assume my banking passwords and email logins had all been changed multiple times since then. Why are these AWS IAM keys so much worse than a normal human password? That's a great question. We have to completely shift our threat model. When we talk about IAM, which is identity and access management. Okay. When a human logs into a system, the security architecture is built entirely around friction. Right. It's annoying on purpose. Exactly. Your password expires

every 90 days. Yeah. You get a two -factor authentication prompt on your phone. Yeah. If you log in from a new country, you get an automated email warning you about an unrecognized device. There are guardrails and alarms everywhere. I mean, if I log in from a new IP, I get like three emails telling me about it. Right. But IAM secrets are fundamentally different. They are designed for machine -to -machine communication. They're these long -lived cryptographic keys meant to be hard -coded into automated scripts so systems can talk to each other without human intervention. So no friction.

Zero friction. Yeah. Because a script cannot check a text message for a 2FA code, right? So these keys generally bypass all those human -centric guardrails. So they don't expire and they don't... trigger alerts when used? They do not expire unless an administrator explicitly revokes them. And crucially, nobody gets a push notification when an IAM key is used to access a cloud bucket. Wow. They operate in total indefinite silence. The window where an unrotated IAM key remains dangerous is measured in years, not days. Years.

Man, finding an IAM key in a 2024 backup is like someone finding a copy of your house keys you hid under a fake rock two years ago and totally forgot about. That's the perfect analogy. You changed the locks on your front door, but that old key still opens the side gate perfectly. And because it's AWS, that side gate might lead directly into the central data center. An attacker can extract that static key from an ancient backup today. use it from a server halfway across the world, and authenticate into your Amazon Web Services environment, looking exactly like one of your own internal trusted automated systems.

Which perfectly sets up the absolute nightmare scenario that escalated on September 3rd. Yes. The September 3rd update. Because the compromise of those silent, long -lived credentials allowed the attackers to move laterally. JetBrains had to confirm that the attackers obtained access that could have allowed them to reach storage containing data for current Cadence users. Right. And that included user source code. Yeah. The gravity of the situation shifts entirely at this point. We move from infrastructure compromise to supply chain contamination. The remediation

guidance they issued is deeply unsettling. They told their customers, quote, Treat all executions, including their inputs and outputs in your cadence project, as potentially untrusted. Yeah, untrusted. That is a heavy word in security. Here's where it gets really interesting. Let me try an analogy here. A standard data breach, like a company losing credit card numbers, is like someone breaking into a soda factory to steal your secret recipe. Okay. Your competitor might make a copycat soda,

which is terrible for business, but the soda you are currently shipping is still safe to drink. Right. The harm is bounded. You know exactly what was lost. But this situation, this isn't sealing the recipe. This is someone breaking into the factory in the middle of the night, bypassing the security cameras, and potentially altering the ingredients on the assembly line without anyone noticing. Yes. And then you ship millions of bottles of that tainted soda to your own loyal customers, having absolutely no idea what's going on. what's actually inside them. That captures the psychological and operational

terror of an integrity breach beautifully. It's terrifying. If we connect this to the bigger picture, most breaches that make the evening news, phishing, identity fraud, database dumps, they're downstream harms. Right. You lose customer data, you face regulators, you pay a massive fine, and you buy everyone credit monitoring for a year. It's an incredibly bad week, but it's a known quantity. You run the playbook. Exactly. Trying to figure out if the software you just compiled and shipped was secretly mortified

by an attacker in your own build environment? Oh, man. That is an existential crisis for a software company. Your continuous integration server, like TeamCity, has deployment credentials. It has network paths carved out into your most sensitive production environments. Because it has to to do its job. Right. It is. quite literally the machine that builds the machines. If its integrity is compromised, everything it touches is compromised. So how do you even begin to prove a negative in that scenario? I mean, JetBrains

essentially told their users they could provide a list of exposed credentials, but warned them not to consider the list exhaustive. Yeah, they had to say that. Because if the attacker had the keys to the assembly line, how can you ever mathematically prove your code wasn't altered? You can't. You really can't. Modern incident response, you have to adopt the assume breach mentality. Okay. What does that look like? You assume every single artifact, every compiled binary, every line of code touched by that system during the compromise window is tainted. Wow. You have to burn the contaminated environment

to the ground, rebuild the infrastructure from clean, verified backups, and re -audit the source code from scratch. Okay, after painting that apocalyptic picture, I think I want to pivot to the practical advice. Good idea. Because it's very easy to listen to this and just throw our hands up in defeat. If you were listening to this right now, maybe you run IT for a mid -sized logistics company or a healthcare startup. How do you actually verify your own security and protect yourself from this specific shape of failure? So the transcript breaks this down into

three highly actionable takeaways. Let's hear them. And the first one directly addresses your assembly line metaphor. You must treat your build systems as highly sensitive production infrastructure. Meaning don't treat your CICD server as just some convenient lower tier developer tool that runs tests in the background. Exactly. It holds the keys to the kingdom. If you wouldn't leave your primary database or your domain controller unpatched and directly facing the public internet, you have no business doing it to your build server. That makes total sense. Hide it behind a strict

VPN. Put it behind an IP allow list. Never expose its management console to the open web. Right. What's lesson two? Lesson two tackles the ticking time bombs. Those long -lived AWS secrets. The house key under the rock. Yes. I understand the ideal is to move to short -lived, automatically rotating credentials. Using roles and temporary tokens instead of static passwords. But what about the legacy stuff? Because, I mean, every company over three years old has a closet full

of legacy scripts holding everything together. Oh, absolutely. And if you absolutely cannot modernize a legacy system and must rely on static keys, you must aggressively document exactly where they live, especially in your archives. Oh, so you have a map of the hidden keys. Right. You have to ask yourself the uncomfortable question. What high -level credentials are frozen inside the database snapshots we took two years ago? Because if you suffer a breach and declare a total credential rotation, you need to actually know what total means. Exactly. Otherwise, you are leaving doors open in the past. Okay. And

that brings us to the third lesson, which I think strikes at the heart of why this happened in the first place. Yeah. Treat patching as a delivery, not a decision. This is critical. Yeah. Deciding to patch a critical vulnerability in a meeting is a decision. Announcing the patch on a Slack channel is communication. Right. But actually protecting your environment. That requires mathematical verification. So when a CISA advisory drops, you don't just approve the patch, assign the IT ticket and like go get a coffee, assuming

the automated endpoint manager handled it. No. You only close the incident ticket when you can produce a definitive verified list of every single affected instance in your entire environment. Wow. Every single one. Every single one paired with a validated version number, proving the patch is physically live on every single one of those boxes. Which is incredibly tedious, unglamorous work. I mean, it's usually nobody's specific job to manually verify the automated patcher didn't skip a server. It's the silent

gap between what management intended to happen and the physical reality on the metal of the servers. Yeah. And strangely enough, despite that catastrophic gap in execution, this incident is also a master class in how a company should communicate during a crisis. Wait, really? You want to praise the company that failed to patch their own flagship product on their own live server? Honestly, absolutely. I don't care why. The ultimate lesson for the industry here isn't about pointing fingers. JetBrains found the breach, disclosed it rapidly, and continually updated

the public as the forensics uncovered a worse and worse picture. They didn't sweep it under the rug. They didn't hide the awkward parts. They explicitly told their customers exactly what was compromised and gave brutal, honest advice about treating executions as untrusted. I guess they own the reality of the gap between their intent and their execution rather than trying to spin it as like a sophisticated, unpreventable nation state attack. Exactly. Transparency during an active incident is incredibly difficult, and they prioritize protecting the wider software

ecosystem over protecting their own immediate PR. That is a fair point. So tracing our steps today. We started with a highly ironic failure where the designers of a security patch failed to apply it to their own front door. We unpacked how that single operational gap allowed attackers to bypass authentication using a deserialization flaw. The swarm of bees. Right, the swarm of bees. We explored the silent, long -term danger of machine -to -machine keys frozen in old backups. And finally, we confronted the existential nightmare

of an integrity breach. The realization that compromised automation tools mean your very source code can no longer be trusted. It serves as a stark reminder that in the realm of security, intent and knowledge are totally meaningless without rigorous verified execution. Well said. As we wrap up, I want to ask you for one final thought. We've spent this entire time talking about the hidden dangers of automation engines and the horror of untrusted code. What is something you think our listeners should take away and mull over on their own, building on what we've

discovered today? Well, this incident raises a profound question about the trajectory of our entire industry. Okay. We are increasingly relying on automated systems and now -generated AI to write, test, build, and deploy our code for us at lightning speed. Oh, yeah. Everyone is pushing for faster automation. Right. We are actively trying to remove the human bottleneck from the software assembly line. But if an underlying automation engine is compromised... and it is moving at a speed far beyond human capacity to

audit, how long would it actually take us to realize that the perfect code our systems are turning out has actually been working against us all along? Oh, that is deeply unsettling. If you outsource the installation of your perfect alarm system to a machine that's been quietly compromised, you're leaving the front door wide open, at scale, without even realizing it. We have to verify the tools that build our tools. Absolutely. Well, thank you for joining us on this deep dive. Keep questioning the systems you rely on every day, verify your patches, and

we will catch you on the next one.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. Iris Ohyama - A Suspicious File in the Cloud, 7.7 Million Customers at Risk, and an Online Store That Went Dark

    Nov 19, 202620 minAudio

    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...

    Credit the people on this episode

  2. Who Gives A Crap - A Marketing Supplier Breached, Six Days to Tell the Client, and Customer Data That Didn't Need to Be There

    Nov 17, 202619 minAudio

    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...

    Credit the people on this episode

  3. Last Week in Tech - An Outlook Zero-Day That Leaks Your Password Hash, Chrome's Eighth Exploited Bug, and Nvidia Without Jensen Huang

    Nov 15, 202621 minAudio

    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...

    Credit the people on this episode

  4. Chainalysis - From "Non-Sensitive" to "All Users": How a Breach Notice Changed in Five Days

    Nov 12, 202619 minAudio

    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...

    Credit the people on this episode

  5. NSW Health - A Dental Voucher Website, Four Gigabytes Taken, and the Providers Whose Details Were Exposed

    Nov 10, 202623 minAudio

    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;...

    Credit the people on this episode