Skip to content
Melo Podcasts Home
CategoriesLanguagesFollowing

Season 1, Episode 5 · DevSec Station

Secrets Management: Stop Playing Whack-a-Mole

18 Jun 2026 · 7 min

Play episode WhatsApp Download

Episode notes

If you've ever committed an API key, password, token, certificate, or other secret to a repository, you're not alone. Most secret leaks don't happen because developers don't care about security. They happen because the easiest place to put a secret is inside the code that uses it. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explains why secrets leak, why "just be careful" isn't an effective security strategy, and how developers can stop playing whack-a-mo...

Transcript

Read the transcript · about 1,040 words, follows along as you listen

SPEAKER_00:Let's normalize something together very quick. If you've ever committed a secret to a repo, you are not alone. And if you haven't, you probably just haven't noticed yet. Trust me, everyone has done it. I know I have. But your repo is not a vault. And just hoping we don't leak secrets is not an actual real strategy. We can do better. Hi, I'm Tanya Jenka, also known as SheHacksPurple. Welcome to DevSecStation, a podcast for software developers who want to build more secure software.

SPEAKER_00:In each episode, I'll share a short practical lesson about secure coding, software security, and how to build safer systems without slowing development down. You can jump in at any episode, at any time. No homework required. This episode is sponsored by MAISE. One of the biggest problems in security right now is that every vulnerability or cloud scanner says everything is critical. And honestly, no one has time for that. MAZES uses AI agents to investigate vulnerabilities in context, so you can focus on the issues that are actually exploitable in your environment and not just theoretically scary.

SPEAKER_00:Their AI agents also generate and prioritize fixes that knock out multiple vulnerabilities at once, which is honestly the kind of scaling that security teams really need right now. Learn more about maze at mazehq.com slash devsec. If you've ever copied a token into a config file, pasted an API key into an N file, or shared credentials just to get something working, this episode's for you. Secrets are what computers use to authenticate to each other.

SPEAKER_00:API keys, certificates, passwords, tokens, all of those things and more are secrets. And that's what we are going to talk about today. Secrets aren't leaked because developers don't care about security. They leak because the easiest place to put a secret is into the code that uses it. Git is great at remembering things, which is exactly why it's terrible for forgetting secrets. And once a secret has been committed, even briefly, it's effectively public forever.

SPEAKER_00:Not because attackers are actively watching you specifically, but because scanning for secrets that have been leaked is automatic, cheap, and consistent. Here's how this usually happens. So you're working locally and you need a token. You paste it into a config file just to test something. You tell yourself, I'm gonna remove that later. But you forget. And later you commit, and that commit gets pushed. A bot scans it within 60 seconds, and your secret has been compromised.

SPEAKER_00:Even if you deleted it right away, it could be too late. Malicious actors are very ready to exploit this type of mistake. And then starts the whack-a-mole. Rotate the key, invalidate the token, update the config, hope that nothing else breaks. This is not a developer failure. It's a workflow problem. So, how do we fix this? A bad approach is reacting every time a secret has been leaked. Rotate the keys, send the warnings, talk about it again during the annual training.

SPEAKER_00:This approach fails because it treats the symptom and not the cause. But a slightly better approach would be telling developers, please don't put secrets in your code. I guess that helps a bit, but it relies on memory and discipline, and that is far from foolproof. The best approach is changing our workflow so committing secrets is difficult or near impossible. This means secrets live outside our repo in a secret management tool. And then they're injected at runtime programmatically.

SPEAKER_00:And our tools stop mistakes before they can cause damage. When the system prevents the leaks for us, developers don't have to be perfect all the time. And I don't know about you, but I'm not perfect. If you do just one thing this week, do this. Get a secret scanner and scan every repo that you actively work on. Here's what I actually mean. Step one, choose a secret scanner. Paid or free, I don't care. It can be built into your platform, it could be a pre-commit hook or a standalone scanner.

SPEAKER_00:The specific tool matters less than you actually running it. Step two, scan all the repos that you touch, not just the ones you're proud of and actively working on all of the ones that you are responsible for, please. Then if you find a real secret, here's what you do next. Step three, rotate that secret immediately. That means generating a brand new one. You need to assume it's been compromised, even if it's really old. Even if it probably wasn't used, you must assume the worst here.

SPEAKER_00:Step four, move that secret out of the code and put it into the secret management tool. This could be a cloud secret manager, a vault, whatever your team uses. The key point here is that the secret no longer lives in your source control, it lives where secrets should be stored. Step five, update the code so now it pulls the secret from the secret management tool instead of having it all hard-coded into your app. If you don't have a secret management tool yet, then this week's homework is very simple.

SPEAKER_00:Ask your boss to get you one. You can frame it like this boss, I found a secret in my code today. That is obviously not good. I don't want it to happen again. This tool will ensure that it never happens again. Please help me make us more secure. You don't need to solve the secrets in all the apps everywhere today. You can just scan your part, fix what you found, and make the next leak much less likely. This is why secrets management matters. Rotating keys might be annoying, but a security incident is way worse.

SPEAKER_00:When secrets live outside of your repo and we have tools helping us block mistakes, we can stop playing whack-a-mole with our secrets. Thanks for listening to DevSecStation. If you enjoyed this episode, please subscribe, share it with a friend, or leave a review. It helps more people discover the show. If you'd like to learn more, I'm Tanya Jenka, also known as SheHacksPurple. And I teach secure coding training for software developers. You can find me online at shehackspurple.ca.

SPEAKER_00:Thank you for being here.

Transcript supplied by the publisher with the episode.

Podcast

DevSec Station

Tanya Janca | SheHacksPurple · Tech & Science · English

DevSec Station is a security focused podcast for software developers who want to create amazing applications. Hosted by Tanya Janca, also known as SheHacksPurple, these short lessons will help you level up.

More from DevSec Station All episodes →

  1. 26 Aug 2026 · 9 min

    How to Do Secure Code Review (When You’re Not a Security Expert)

    Secure code review isn't about finding obscure vulnerabilities or thinking like an elite hacker. It's about verifying that the security controls your application depends on are actually present, in the right place, and correctly implemented. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explains how developers can perform effective secure code reviews without being security experts. You'll learn what security controls to look for, how trust boundaries help ...

  2. S1 · E9 · 12 Aug 2026 · 8 min

    The Most Common Secure Coding Mistakes Good Devs Make

    Security bugs aren't usually caused by 'bad developers'. More often, they're the result of good developers making rational decisions under deadlines, competing priorities, and imperfect systems. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explores why common secure coding mistakes are often incentive problems rather than knowledge problems. You'll learn why insecure patterns emerge, why simply telling developers to "be more careful" doesn't work, and how ...

  3. S1 · E8 · 29 Jul 2026 · 7 min

    Secure Defaults Beat Secure Training

    Security training has its place. But if training alone solved security problems, we wouldn't keep seeing the same vulnerabilities appear over and over again. The real problem usually isn't that developers don't know what to do; it's that the easiest path is often an insecure one. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explains why secure defaults are one of the most effective security controls you can implement, why relying on memory and willpower ra...

  4. S1 · E7 · 15 Jul 2026 · 6 min

    Why Current Security Tools Fail Developers

    Security tools are supposed to help developers build safer software. But sometimes it seems like they create more frustration than security. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explains why many security tools overwhelm developers with alerts, how alert fatigue erodes trust, and why "more findings" doesn't mean "more security." You'll learn how to tune your classic AppSec tools so they surface meaningful issues instead of creating noise that every...

  5. S1 · E6 · 1 Jul 2026 · 8 min

    Vibe Coding, Copilots, and Security Drift

    AI coding assistants can help developers move incredibly fast. But this new speed comes with a new challenge: security drift. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explores how tools like GitHub Copilot, ChatGPT, Cursor, and other AI coding assistants can unintentionally change the security assumptions your software was built on. You'll learn what security drift is, why it happens so quietly, and how to keep the benefits of AI-assisted development w...

  6. S1 · E4 · 4 Jun 2026 · 7 min

    Supply Chain Is More Than Just Dependencies

    Most developers think software supply chain security starts and ends with dependencies. But modern supply chain attacks don't stop there. Attackers look for paths into your software, and those paths often run through developers, CI/CD systems, build tools, deployment pipelines, and other trusted parts of the software delivery process. This episode is sponsored by Maze. In this episode of DevSec Station, Tanya Janca explains why the software supply chain is much bigger than libraries and pac...

  7. S1 · E3 · 21 May 2026 · 8 min

    Malicious Dependencies Aren’t an Accident

    Malicious dependencies are not accidents. They are often intentionally designed to look trustworthy so developers install them without hesitation. In this episode of DevSec Station, Tanya Janca explains how attackers use typosquatting, dependency confusion, fake packages, and even AI-generated recommendations to compromise developer environments and steal credentials. This episode is sponsored by Maze. You’ll learn: • how malicious packages trick developers • why dependency attacks work...

  8. S1 · 22 Apr 2026 · 2 min

    NPM Supply Chain Attack: Active Worm Stealing Tokens, SSH Keys, and Credentials

    🚨 Emergency DevSec Station update. There’s an active npm supply chain attack happening right now. Malicious npm packages are running install scripts that quietly steal: • SSH keys • AWS credentials • GitHub tokens • Browser passwords • Crypto wallets From there, the attack uses your npm publish token to spread into every package you maintain. That’s how this turns into a worm across the npm ecosystem. This is not theoretical. It’s already in the wild. 👉 Immediate...

  9. S1 · E2 · 14 Apr 2026 · 10 min

    How Modern Supply Chain Attacks Really Happen (Step-by-Step Breakdown for Developers)

    What if a supply chain attack didn’t start with a complex exploit… but something completely normal? A typo. A copy-paste. Even an AI suggestion. In this episode, Tanya Janca breaks down how modern supply chain attacks actually happen inside everyday developer workflows. These attacks aren’t one big moment. They’re a series of small, reasonable decisions that quietly introduce risk. You’ll learn: • Why supply chain attacks are a process, not a single event • How attacke...

  10. S1 · E1 · 21 Mar 2026 · 6 min

    Developers Are Now Targets: How Supply Chain Attacks Actually Reach You

    Developers are no longer just building software. They’re being targeted directly. In this episode, Tanya Janca explains how supply chain attacks reach developers through everyday tools, packages, and workflows. These attacks don’t feel like attacks at first. They look like normal development work until it’s too late. You’ll learn: • How supply chain attacks reach individual developers • Why developer environments are now high-value targets • Where risk shows up in dail...

Take it with you

The Melo app keeps playing with the screen off, works in the car and on your watch, wakes you to your station, and browses the whole catalogue offline. Free, no ads, no account.

Get it on Google Play