The Backup Wrap-Up

A PyPI software supply chain attack hit LiteLLM — a library pulled into developer environments 97 million times a month — and if you use it, you may already be compromised. This wasn't a fake package or a typo-squatting trick. Attackers stole real credentials, published malicious code as the real thing, and walked out with SSH keys, cloud credentials, Kubernetes tokens, API keys, and more — all encrypted and sent home before anyone knew what happened.
I'm doing something I've never done before: an emergency episode, recorded and published immediately because this is that serious. I brought in Dr. Mike Saylor, co-author of our book Learning Ransomware Response and Recovery, and my co-host Prasanna Malaiyandi to break down exactly what happened, how to find out if you were hit, and what you need to do to protect yourself going forward.
We open with a story from 1982 that perfectly captures what this attack really is — getting poisoned by something you trusted completely. That framing matters. This wasn't a failure of the library. It was a failure of the supply chain. And it can happen again.
Chapters:
00:00:00 - Intro: Why this is an emergency episode
00:01:35 - Meet the guests: Dr. Mike Saylor and Prasanna Malaiyandi
00:02:31 - The Tylenol poisoning analogy and what it means for software supply chains
00:05:51 - What LiteLLM is and what the malware actually did to your environment
00:09:04 - Dependencies explained: why you're affected even if you didn't install LiteLLM directly
00:12:24 - How to find out if you were hit: the first things to check right now
00:14:23 - IOCs and TTPs: what to look for in your logs and on your systems
00:19:07 - Network indicators: unusual traffic and what it tells you
00:22:12 - How security teams can find out if developers installed it without telling anyone
00:30:38 - Action items for the future: inventory, pinning, and hash verification
00:36:55 - Sandboxing new downloads before they touch your environment
00:37:59 - Immutable backups: why this attack makes the case for them
00:40:33 - Modern authentication: MFA, its limits, and why passkeys matter
00:46:53 - Where to get threat intel so you hear about attacks like this faster
00:53:23 - Wrap-up
If you installed or upgraded LiteLLM on or after March 24, 2026 without a pinned version, stop what you're doing and listen to this episode first.
The story:
https://futuresearch.ai/blog/litellm-pypi-supply-chain-attack/
https://securitylabs.datadoghq.com/articles/litellm-compromised-pypi-teampcp-supply-chain-campaign/
https://snyk.io/articles/poisoned-security-scanner-backdooring-litellm/
https://www.wiz.io/blog/threes-a-crowd-teampcp-trojanizes-litellm-in-continuation-of-campaign
https://checkmarx.com/zero-post/python-pypi-supply-chain-attack-colorama/
https://www.upwind.io/feed/litellm-pypi-supply-chain-attack-malicious-release
https://docs.litellm.ai/blog/security-update-march-2026
https://www.helpnetsecurity.com/2026/03/25/teampcp-supply-chain-attacks/
https://www.darktrace.com/resources/the-cisos-guide-to-cyber-ai
https://securitylabs.datadoghq.com/articles/litellm-compromised-pypi-teampcp-supply-chain-campaign/
Resources:
https://www.stopransomware.com
https://www.cisa.gov
https://www.cve.org/

Fileless malware is one of the most dangerous attack types out there — it never writes to your hard drive, lives entirely in RAM, and can steal your credentials before your antivirus has any idea it's there. In this episode, I bring in Dr. Mike Saylor — my co-author on Learning Ransomware Response & Recovery — to break down exactly how this attack works, why it's so hard to detect, and what you can actually do to protect yourself.
Mike walks us through how fileless malware hides in memory, how bad guys maintain their foothold even after a reboot by modifying registry keys or rewriting the operating system itself, and why the ArcGIS attack is a perfect real-world example — attackers sitting undetected inside a network for two years. We also get into MFA, specifically why a lot of MFA setups are done wrong, why passkeys are the better answer, and when it's time to bring in an EDR or XDR tool.
Fair warning: the action items here are a bit more advanced than our usual stuff. Think of this as the 401k conversation — don't have it before you've built your emergency fund. But this is stuff you absolutely need to know.
00:01:26 - Welcome & intro
00:04:43 - What is fileless malware?
00:09:16 - How fileless malware achieves persistence (ArcGIS case study)
00:15:02 - Can fileless malware spread beyond one machine?
00:16:43 - Defending yourself: MFA done right
00:20:38 - Why passkeys beat MFA
00:23:00 - EDR and XDR explained
00:28:03 - How modern EDR tools detect fileless malware
00:30:01 - Wrap-up and action items

A living off the land attack is one of the sneakiest techniques in a ransomware operator's playbook — and in this episode, Dr. Mike Saylor breaks down exactly what it is, how it works, and what your organization can actually do about it.
Instead of bringing their own tools into your environment (which might trip your alarms), attackers just use what's already there. PowerShell. WMI. RDP. The same tools your admins run every single day. To your monitoring systems, it looks completely normal. That's the whole point.
Mike and Curtis cover why attackers prefer your tools over their own, how recon can quietly run for 30 to 90 days before the attack goes loud, and what defenders can actually do about it — removing admin privileges, system hardening, golden images, application whitelisting, and free tools like Nmap and Wireshark. There's also a match.com story involving organized crime and a wooden casket on someone's front porch that you really don't want to miss.
0:00 - Intro
1:21 - Welcome and Book Announcement
3:28 - What Is a Living Off the Land Attack?
5:38 - Real-World Example: Conti Ransomware and WMI
8:12 - Why Attackers Use Your Tools Instead of Their Own
13:05 - Admin Privileges: Best Practice vs. Reality
17:31 - The Louvre Heist Analogy
20:08 - Recon Phase: Low and Slow
24:16 - What Defenders Can Do
25:55 - RDP and Remote Access
29:48 - The Recon Timeline: 30-90 Days
30:48 - PowerShell and System Hardening
34:10 - Network Discovery Tools (Nmap and Wireshark)
37:37 - Application Whitelisting and Geo IP Blocking
42:08 - Action Items and Wrap-Up

Password manager vulnerabilities aren't just about bad code — and a new research paper out of Zurich just proved it. Researchers analyzed three of the most popular password managers and found fundamental design flaws baked into the very architecture that's supposed to keep your credentials safe. Curtis and Prasanna break it all down and tell you what to do about it.
If you've ever been that person who asks "but what if the password manager gets hacked?" — this episode is for you. And if you haven't been asking that question, you probably should start. A research team looked at LastPass, Bitwarden, and Dashlane — products with a combined 60 million users representing roughly 23% of the password manager market — and what they found wasn't sloppy programming. It was something harder to fix: architectural problems at the core of how encrypted vaults work.
Curtis walks through how the zero-knowledge encryption model works, why the vault recovery process creates an inherent trust problem, and why the researchers were able to exploit that trust by impersonating the server during vault recovery. Prasanna adds another layer — the field-level encryption issues inside the vaults themselves, where there's no strong verification that data hasn't been manipulated. It's not theoretical. It's a real attack surface.
The good news? Curtis still believes password managers are the right tool for today — better than sticky notes on a monitor (yes, he saw that in real life) and better than reusing passwords. But he's also clear that passkeys are the right direction for the future, even if the current implementation is still a little rough around the edges.
https://eprint.iacr.org/2026/058.pdf
https://www.theregister.com/2026/02/16/password_managers/
https://www.forbes.com/sites/daveywinder/2026/01/23/lastpass-issues-critical-warning-for-users---password-attacks-underway/

What is an initial access broker — and why does it matter to your organization? In this episode, W. Curtis Preston and Prasanna Malaiyandi are joined by Dr. Mike Saylor of Black Swan Cybersecurity to break down the role of the initial access broker in today's ransomware attacks.
Most people picture ransomware as a single bad guy with a keyboard. The reality is way scarier. There's an entire criminal supply chain out there, and the initial access broker is the specialist at the front of it. These are the people who do nothing but break in — stealing credentials, exploiting vulnerabilities, hijacking sessions — and then sell that access to other criminals who do the dirty work. Dr. Mike Saylor walks us through a real case study from 2024 where an employee's personal Gmail account — with a Google Docs folder literally named "passwords" — became the entry point for a corporate ransomware attack months later. This stuff is real, it's happening constantly, and most organizations have no idea how exposed they are.
We cover what IABs target, how they package and sell access, what "coincidental passwords" are and why they're so dangerous, and what practical steps you can take today to make your organization a harder target.
Chapters:
00:00 - Intro: What Is an Initial Access Broker?
02:12 - Welcome, Introductions, and a Little Judging
03:33 - Defining the Initial Access Broker
04:31 - Real Case Study: How Bob's Gmail Became a Corporate Breach
07:16 - How IABs Package and Sell Access
10:32 - How Stolen Credentials Get Bundled and Priced
29:48 - RDP, VPN Vulnerabilities, and What IABs Are Hunting
32:54 - Web Shells Explained
35:08 - Session Hijacking and Man-in-the-Middle Attacks
36:16 - Would Eliminating IABs Stop Ransomware?
36:49 - How the Cybercriminal Ecosystem Evolved to Create IABs
39:51 - Practical Takeaways: What You Can Do Right Now
40:45 - The Numbers: 37 Billion Records and the ShinyHunters Breach