Cover art for Who Scrapes Leaked API Keys from GitHub?
Episode 6741 custom

Who Scrapes Leaked API Keys from GitHub?

In controlled canary tests on GitHub, automated bots discovered and exploited an exposed AWS credential in as little as forty-seven seconds.

30:14 Transcript

0:00
0:00
Episode Details
Episode ID
MWP-6945
Published
Duration
30:14
Audio
Direct link
Pipeline
V5.36
TTS Engine
omnivoice
Script Writing Agent
GLM-5.3

AI-Generated Content: This podcast is created using AI personas. Please verify any important information independently.

The prompt

The prompt that started this episode, as sent in (production notes for the hosts removed).

Everyone who's used GitHub for any length of time has probably, at least once, had the unpleasant experience of accidentally leaking a secret. With hooks and server-side filtering, there are a lot of mechanisms in place to prevent this, but everyone learns the hard way at least once, I reckon. One version of events is that you get a notification from something like GitGuardian that a commit contained an API key, recommending you rotate it immediately. In other cases, services proactively revoke keys that were exposed in leaks. But there's a third case I've seen once or twice over the years: somebody commits an API key, says "oh crap", and immediately force-removes it from the git history. The thought that flashed across my mind is: are there bots and scrapers that index the internet continuously and just mop up these short-lived exposures? It sounds like a nefarious den of servers, and you'd have to devote considerable resources if you wanted to do this. But I've always wondered how even momentary exposures can lead to compromises on today's extensively monitored internet. Is this a thing that exists, and if so, who are the bad guys in this story?

Accidentally pushing an API key to a public GitHub repository triggers a high-speed race between automated defenders and opportunistic attackers. Automated scanners can discover exposed credentials in as little as forty-seven seconds, with exploitation sometimes occurring within a single minute. While cloud providers react quickly—Amazon Web Services can attach a quarantine policy to a leaked IAM user in just ten seconds—that defensive response merely restricts specific high-risk actions rather than revoking the credential outright. Consequently, unmonitored permissions like reading Secrets Manager or scanning DynamoDB tables can leave compromised environments exposed. Furthermore, pull requests to prominent repositories dramatically accelerate compromise by broadcasting secrets to an extensive array of continuous automated scrapers.

Sources

What the research for this episode read before the script was written. Primary sources first.

  1. GitHub Docs, Push protection, retrieved 2026-11-22 primary
  2. GitHub Docs, Secret scanning, retrieved 2026-11-22 primary
  3. GitHub Docs, Secret scanning detection scope, retrieved 2026-11-22 primary
  4. GitHub Docs, About secret scanning alerts, retrieved 2026-11-22 primary
  5. GitHub Docs, Enabling push protection for your repository, retrieved 2026-11-22 primary
  6. Meli, McNiece, Reaves, How Bad Can It Git? Characterizing Secret Leakage in Public GitHub Repositories, NDSS 2019, retrieved 2026-11-22 primary
  7. Truffle Security, Dylan Ayrey, The Anatomy of a GitHub Secret Leak: From Commit to Compromise, 2026-02-20, retrieved 2026-11-22 primary
  8. Clutch Security, Shattering the Rotation Illusion: Part 1, 2024-12-03, retrieved 2026-11-22 primary
  9. Unit 42, CloudKeys in the Air: Tracking Malicious Operations of Exposed IAM Keys, 2023-10-30, retrieved 2026-11-22 primary
  10. Truffle Security, How to Scan Force Pushed Commits for Secrets, retrieved 2026-11-22 primary
  11. GitGuardian, State of Secrets Sprawl 2025, 2025-03-11, retrieved 2026-11-22 primary
  12. GitGuardian blog, The State of Secrets Sprawl 2025, 2025-03-11, retrieved 2026-11-22 primary
  13. GitGuardian, The State of Secrets Sprawl 2026, retrieved 2026-11-22 primary
  14. GitGuardian blog, The State of Secrets Sprawl 2026, retrieved 2026-11-22 primary
  15. GitHub, smakarim/revenant, retrieved 2026-11-22 primary
  16. GitHub, chrisns/example-orphaned-commit-repo, retrieved 2026-11-22 primary
  17. AWS Builder Center, From git push to crypto miner in 5 minutes, retrieved 2026-11-22
  18. Carter Appleton, Your Secrets Are Still on GitHub, retrieved 2026-11-22
  19. The Hacker News, The State of Secrets Sprawl 2026: 9 Takeaways for CISOs, 2026-03, retrieved 2026-11-22
  20. Passwork, The state of secrets sprawl in 2026, retrieved 2026-11-22
  21. The Register, Cryptojackers steal AWS credentials from GitHub in 5 minutes, 2023-10-30, retrieved 2026-11-22
  22. Neodyme, Hidden GitHub Commits and How to Reveal Them, retrieved 2026-11-22

Mentions

  • BigQuery Google's serverless data warehouse
  • Claude Code Anthropic's agentic coding CLI tool
  • Clutch Security Ran eleven GitHub exploitation timeline scenarios
  • EleKtra-Leak Named cryptojacking operation cloning repos for AWS keys
  • Etherscan Blockchain explorer found leaking keys in dangling commits
  • GH Archive Public dataset of every GitHub event since 2015
  • GitGuardian Secrets security and leak detection platform
  • Monero Privacy-focused cryptocurrency
  • Truffle Security Ran AWS key canary test, built Force Push Scanner
  • Unit 42 Palo Alto research team behind EleKtra-Leak report

Downloads

Episode Audio

Download the full episode as an MP3 file

Download MP3
Transcript (TXT)

Plain text transcript file

Episode Book (PDF)

The episode's record — date, duration, models, sources — with the full transcript

#6741: Who Scrapes Leaked API Keys from GitHub?

Corn
There's a specific feeling every GitHub user knows. You push a commit, the terminal says everything's fine, and then somewhere between the coffee machine and your chair your brain finishes the diff you just wrote and your stomach drops through the floor.
Herman
And the next thirty seconds are always the same. Re-read the diff. Confirm it. Panic. Google "remove commit from history" for the four hundredth time, because you've done this before and you never learn it.
Corn
Daniel sent us a prompt about exactly that moment. He's seen the GitGuardian notification email, the "rotate this key immediately" one. He's seen services just revoke a key outright. But the case that nags at him is the third one, the person who commits an API key, says a word I won't repeat before breakfast, and immediately force-removes it from history. His question is whether there's some "nefarious den of servers" out there indexing everything continuously and mopping up these short-lived exposures, and if so, who's running it.
Herman
And the short answer is yes, it exists, and the longer answer is much stranger than the den of servers you're imagining.
Corn
Which is my favourite kind of answer.
Herman
The question underneath Daniel's question is really about a time window. Not "do leaks happen," we know they happen, but how long is the gap between a key landing in a public repo and someone using it? And is that gap small enough that even a panicked force-push buys you nothing?
Corn
Give me the number, Herman. I know you've been holding it since you read the prompt.
Herman
Forty-seven seconds. Truffle Security ran a canary test in February — Dylan Ayrey planted a real AWS key in a public repo, pushed it, and watched what happened. Automated scanners found the key within forty-seven seconds of the push. Within four minutes there were API calls coming from an IP in Eastern Europe.
Corn
Forty-seven seconds. I take longer than that to decide I'm going to stand up.
Herman
And the backdrop is why that speed is even possible. GitGuardian's latest count is nearly twenty-nine million new secrets in public GitHub commits in one year. Up thirty-four percent year over year, up a hundred and fifty-some percent since twenty twenty-one. This isn't an occasional accident. It's a continuous, renewable stream. A scanner watching GitHub is a fisherman standing under a fish rain.
Corn
And I want to be precise about what twenty-nine million means, because it's easy to hear that number and picture twenty-nine million distinct keys. It's not distinct secrets, right? It's detections.
Herman
Right, good distinction. The same key committed to five repos, or the same key committed five times as someone tries to fix it, counts multiple times. But even with duplicates factored out, the volume is enormous, and the growth curve is the real story — this is a problem that's getting structurally bigger, not just cyclical. More developers, more services, more keys per project, more pushes. Every one of those trends pushes the number up independently.
Corn
So the arc for today: how keys get out, what's supposed to catch them, why deletion doesn't work the way people think it does, and then the actual bad guys, who have a name and a business model and, apparently, a grudge against security researchers.
Herman
Let's start with how it actually leaks, because it's less glamorous than people imagine.
Corn
My guess has always been the dotfiles. The .env file that works locally, so it works when you push.
Herman
That's a big chunk, and the more general version of it — keys embedded directly in code, or an actual key file that someone commits with everything else in the directory. Think about how a project actually gets built. You're prototyping locally, the fastest path is to paste the key straight into the script, it works, you move on. Three weeks later you're tidying up, you init a repo in that directory, and git add dot grabs everything. The .env, the credentials.json, the scratch file named test_final_v2.py that has four keys in it from four different debugging sessions.
Corn
The scratch file is the one that gets me, because it never looks like a credentials file. Nobody greps for that. It's not called secrets.txt, it's called notes.txt, and it has a key in it because you were pasting things into a terminal and wanted a backup.
Herman
The mental model people have is a leak looks like a leak — a file with a lock on the icon. In reality it looks like everything else in the repo. The first serious look at this was the NDSS paper back in twenty nineteen, "How Bad Can It Git," Meli, McNiece and Reaves. They scanned billions of files over nearly six months of real-time commits. Over a hundred thousand repositories affected, thousands of new unique secrets every day, and the majority of them still sitting there weeks later.
Corn
And the reason they sit there is that nobody's actually required to do anything about it.
Herman
Right. Walk through the incentives. GitHub sends you an email if your repo is enrolled in secret scanning. The cloud provider may alert the account owner. But there's no mechanism anywhere that says "this key is now revoked." The only person who can rotate the key is the key's owner, and the owner is frequently a person who pushed at eleven at night, got the email at eleven-oh-one, thought "I'll deal with it tomorrow," and the key outlived the project, the job, and sometimes the company.
Corn
And the paper also tested the obvious countermeasures — you said they tried limiting things?
Herman
They did. Multiple secret values before an alert, rate limiting the queries — and their conclusion was these techniques all fail to limit systemic large-scale secret exposure. Which is a very academic way of saying "we tried the sensible ideas and the problem shrugged." And you can see why. If you require the same secret to appear multiple times before alerting, you've just told every attacker to use a key exactly once. The countermeasure selects for the attack it can't see.
Corn
What's GitHub's own machinery, then? Because GitHub does do secret scanning. I've gotten the emails.
Herman
Two layers. Secret scanning runs across your entire Git history on all branches, looking for known secret types. Push protection is the more interesting one — it blocks the push before it ever reaches the repository. The commit with the key simply doesn't go up.
Corn
That sounds like the whole problem solved.
Herman
Two problems with that. First, push protection isn't on by default. You have to enable GitHub Secret Protection at the repo, org or enterprise level, and a solo developer with a weekend project almost never has. Second, the detection is narrower than people assume. It's pattern-based, and for pattern pairs like AWS keys, it only fires if the key ID and the secret are in the same file and both get pushed.
Corn
So split the key across two files and the scanner is blind.
Herman
And in practice people split them across a config file and a code file all the time, without ever intending to evade anything. The gap is accidental more often than deliberate.
Corn
But hold on — how does the attacker's scanner handle that, then? If the good scanner can't see a split key, how does the fisherman catch it?
Herman
Mostly it doesn't, is the honest answer. The attackers are running the same kind of dumb pattern matching, and a split key survives both sides. The keys that get mopped up in forty-seven seconds are the plaintext, obvious-prefix, single-file ones. Which sounds like a small consolation until you remember that the plaintext obvious ones are the overwhelming majority of what actually leaks. The sophisticated evasion cases exist, but the volume is all in the careless end.
Corn
Fine. Now walk me through the defender's side of the timeline, because you said the defenders are actually fast.
Herman
Fast. Unit 42 did a controlled test — planted key, public repo, stopwatch. At ten seconds, AWS attached a quarantine policy to the leaked IAM user. Eleven seconds, GitHub emailed the repo owner. Twelve seconds, an alert appeared in the AWS Health dashboard. Twenty-one seconds, AWS emailed the account owner. Fifty-four seconds, a support case opened automatically with the key and user details.
Corn
Ten seconds. That's faster than my fastest physical reaction by several orders of magnitude.
Herman
And it's worth pausing on how strange that is, because it means AWS detected the leak from the outside. They're not watching your laptop. They saw the key appear somewhere public — the same scanners the attackers use, essentially — and they reacted to their own credential showing up in the world. The defensive perimeter now includes the public internet watching your keys for you.
Corn
But here's the part I want to be careful with, because it's the misconception.
Herman
Yes, and it's the big one. Quarantine sounds like someone switched the key off. They didn't. AWS does not disable the leaked key. The quarantine policy is a deny-list — explicit Deny statements on the actions attackers abuse most. Spinning up compute, creating new IAM users and roles, reading and deleting S3 objects, even invoking Bedrock models, all denied.
Corn
So it's a list of things you can't do rather than the key being dead.
Herman
And the list has holes. The version three policy doesn't cover reading values out of Secrets Manager, and it doesn't cover DynamoDB scans. There's a path through the front door that's bolted, and a side door ajar. My favorite detail, if favorite is the word, is that the quarantined user can't even delete its own key — updating or deleting access keys is denied too. The policy description literally reads "Do NOT remove this policy."
Corn
A quarantine where the patient can't check himself out but also can't stop strangers reading his file.
Herman
That's the shape of it. And you can see why they design it that way — if the quarantined user could remove the policy, the attacker's first move would be to remove the policy. It has to be sticky to mean anything. But the side effect is that the key sits in this half-alive state indefinitely, and half-alive is a spectrum the attacker gets to explore.
Corn
Now, the attacker's side of the same timeline.
Herman
Clutch Security ran eleven scenarios on GitHub in December of twenty twenty-four — forking Kubernetes and pushing a key, keys in dotfiles, in Terraform state, in pull requests. Average time to exploitation: six point six minutes. Average time for AWS to alert: one point four minutes. The fastest exploitation was one minute.
Corn
One minute.
Herman
They called that scenario "What the Fork." The key went up in a pull request to the original repo, and someone used it inside sixty seconds. Their own line was that it's the time it takes to pour your coffee or start a standup meeting.
Corn
Faster than the standup, in my experience. But walk me through why the fork scenario was fastest, because that's not obvious to me. What's special about a pull request?
Herman
Reach, essentially. A push to your own repo is a tree falling in a forest that only your followers watch. A pull request to a major project like Kubernetes puts the key's content into one of the most-watched streams on the platform. Every automated system that monitors activity on big repos — and there are many, for legitimate reasons — sees the diff. The attacker's scanner doesn't have to be fast if the delivery mechanism is a megaphone.
Corn
So the exposure isn't just a function of time, it's a function of audience.
Herman
A key in a private repo that goes public later, or a key in a repo nobody watches, can sit for a long time. A key in a PR to Kubernetes has an audience of thousands of bots within seconds.
Corn
There's one quiet exception in the Clutch data, though.
Herman
Yes — a key posted in a GitHub issue went completely unexploited during the test window. Nobody's really explained why. Everything else was minutes. My suspicion is it's about where the scrapers point their attention — issues may simply be lower on the monitoring stack than code and PRs — but that's speculation, and it's one data point.
Corn
And that's answering Daniel's first case, the notification email. GitGuardian and the scanning services see the key, they alert, sometimes the provider quarantines. But alerted is not safe — the deny-list has those holes and the key itself is still alive until someone rotates it by hand.
Herman
And that gets us to Daniel's third case, and honestly the most interesting one. The panic-delete.
Corn
The oh-crap force-push.
Herman
Here's the mechanism, and it's the part almost everybody gets wrong. Force-pushing doesn't delete anything. It moves the branch pointer. The commits that were on the branch before the force-push become what Git calls dangling commits — orphaned, no branch pointing at them — but GitHub retains them in the repository's object pool. There's no documented retention policy, no cleanup schedule anyone can point to. The commit with your key in it is still on GitHub's servers. It's just not on your branch.
Corn
And this is the thing people don't get about Git, right? The mental model is a filing cabinet — remove the file from the drawer and it's gone. But Git is more like a library where the catalog card points at the book. Rip up the catalog card and the book is still on the shelf. It's just uncatalogued.
Herman
That's a better analogy than most of the ones in the documentation. And the shelf is public. Invisible from the repo page, but fetchable.
Corn
Fetchable, if you know the SHA. Which, surely, is the hard part?
Herman
And this is the beautiful, terrible part — knowing the SHA is free, because the panic itself publishes it.
Corn
Go on.
Herman
GitHub's Events API records every push, and each push event includes the SHA that was displaced. So imagine the exact sequence. You push a commit with a private key. You panic, understandably. You run git reset hard to drop the last two commits, and force-push. That force-push is a PushEvent with an empty commit list — nothing new went up — but the event's "before" field holds the SHA of the commit you just displaced. The dangerous one.
Corn
So the record of your deletion contains the address of the thing you deleted.
Herman
That exact pattern. It's like burning a letter but the postal service keeps a log of every address ever delivered to, and the log is public, and the fire doesn't actually destroy paper anyway.
Corn
And a researcher named Carter Appleton built tooling around it.
Herman
He scanned a friend's repository with a normal secret scanner — nothing. Then he went after the dangling commits and found a private key. Two more API keys and another private key across other repos in the same organization, all in dangling commits, all invisible to the standard scan. Then he pointed it at other organizations and found many leaking at least API keys this way. Real ones. Etherscan. Alchemy.
Corn
Those aren't hobby repos. Those are companies whose entire product is blockchain infrastructure. If there's a category of organization you'd expect to have secret hygiene nailed, it's the ones whose customers lose real money when they don't.
Herman
And it still happened to them, which is the lesson. The dangling-commit blind spot doesn't care how mature your org is, because it's a gap in the tooling everyone uses. Your scanner scans history reachable from branches. The dangling commits aren't reachable from branches. Same tools, same people, same blind spot.
Corn
And Truffle Security generalized the whole thing.
Herman
Into their Force Push Scanner. The substrate is GH Archive — a public dataset of every GitHub event going back to twenty fifteen. Twenty-six terabytes, sitting on BigQuery, queryable by anyone for about a hundred and seventy dollars if you want all of it. Truffle maintains a much smaller subset, around two gigabytes, of just the force-push events.
Corn
Two gigabytes. The whole pantheon of human panic, compressed. That's smaller than a movie.
Herman
Smaller than a lot of movies. Their estimate from that dataset is tens of millions of dangling commits publicly accessible right now. And the researcher behind the original technique, Sharon Brizinov, found hundreds of live secrets in them and earned twenty-five thousand dollars in bug bounties doing it.
Corn
As a white hat. The same pipeline with the bounties removed is the black hat.
Herman
Same query, different destination for the findings. To be fair to the deletion instinct — it sometimes does work. If you fetch the displaced SHA directly, occasionally you get an error saying the commit object is no longer on GitHub's servers, whether from routine garbage collection or a deletion that went through support. But it's not reliable, it's not something you can trigger yourself, and if even one fork exists, all commits stay accessible through the fork network. GitHub has confirmed that's by design.
Corn
So the answer to "is it really gone" is no, mostly, unreliably, and never in a way you control.
Herman
Daniel asked whether anyone's actually mopping these up. Whether the den of servers is real. Unit 42 gave that question its best answer in October of twenty twenty-three with the operation they named EleKtra-Leak.
Corn
Named for a Greek cloud nymph, which is almost flattering.
Herman
The other half of the name is from the first three characters of the passwords the actors used. The operation: automated tools continually cloning public GitHub repositories and scanning for exposed AWS IAM credentials. Their measured time from exposure to the key being used was under five minutes.
Corn
Continually cloning. How do they know what's new? Do they just re-clone everything on a loop?
Herman
That's the mundane horror of it — they don't need to re-clone anything. GitHub lets you list all public repositories, and you can watch for changes, which is the same feature that lets the ecosystem track new projects in real time — and it lets a threat actor track new repos and new pushes in real time. Nothing exotic. Long-lived AWS keys start with AKIA, they're trivially pattern-matched, and the marginal cost of scanning one more push is basically zero.
Corn
So the "den of servers" is a cron job.
Herman
Functionally, yes. The sophistication people imagine — the underground data center, the indexing cluster — is all projection. The actual apparatus is a script that treats GitHub like a firehose it's allowed to drink from for free.
Corn
Well, on that note, here's everyone's favourite segment. Dorothy's History of Toast.
Herman
Mum! Yes!
Dorothy
Hello dear, it's Dorothy, with Dorothy's History of Toast.
Dorothy
Melba toast is named after the opera singer Nellie Melba, and the chef Auguste Escoffier is credited with it, in the eighteen nineties.
Dorothy
You'd think a singer would want something grander than a bit of dry cracker, but there you are, things rarely turn out grand.
Dorothy
Anyway, your father's put the kettle on and I've got a wash to see to, so I'll let you go, bye bye sweetheart.
Corn
Bless her.
Herman
She's right about Escoffier, for the record. Both dishes.
Corn
Back to the den of servers. What did they actually do with the keys?
Herman
Cryptojacking. Between the end of August and early October twenty twenty-three, Unit 42 observed four hundred and seventy-four unique miners on what they believe were actor-controlled EC2 instances — most likely a specific large instance type — mining Monero.
Corn
Monero because you can't trace the wallet.
Herman
Unit 42 said exactly that. They cannot track the wallet, so nobody knows what the operation actually earns. Four hundred and seventy-four miners running for five weeks on large instances gives you a rough sense of the scale without ever giving you the number.
Corn
An AKIA key sitting in a repo is exactly what we were talking about — a permanent identity just lying there in plaintext.
Herman
This crew has been at it a long time. Unit 42 traces the earliest activity to December of twenty twenty, linking it to an earlier report through shared custom mining software. So you have an operation running the same automated pipeline for years, which tells you it pays.
Corn
Here's the detail that separates this from a script in someone's bedroom, though. Tell them about the blocklist.
Herman
Yes — the counter-forensics. The actor appeared to blocklist AWS accounts that routinely expose IAM credentials. Their read is that accounts which keep leaking keys looked like obvious honey traps set by researchers, so the actor simply skipped them.
Corn
A cryptojacking crew practicing threat modelling.
Herman
It worked, too. Unit 42 had to automate the creation of randomized fresh AWS accounts with over-permissive credentials just to keep the operation in view. The other detail from their methodology: when they first encoded their planted keys in Base64, no threat actor picked them up at all.
Corn
Encoding defeated the scanners.
Herman
In that one test, yes. It's a single anecdotal observation, not a measured result, and I'd resist building anything on it. But it's suggestive about what the scrapers are actually doing — dumb, fast, pattern-matched, plaintext. Which, to Daniel's question, is the whole answer to how momentary exposures get mopped up. The window between push and exploitation is minutes — forty-seven seconds to discovery in the Truffle canary, six point six minutes average in Clutch's tests — and the panic-delete leaves a recoverable SHA in a public event log. You're not outrunning the scanner by deleting. You're filing a public notice of where to look.
Corn
The "considerable resources" Daniel imagined? Not required.
Herman
That's the misconception worth killing. GH Archive is free to access, BigQuery charges by the scan, the force-push subset is two gigabytes. One researcher turned it into twenty-five thousand dollars in legitimate bounties. The den of servers is a laptop and a script and a free dataset.
Corn
One more strand before we're done — the AI numbers.
Herman
GitGuardian's twenty twenty-six report has AI-service secrets at over one point two million for the year, up eighty-one percent. And commits co-authored by Claude Code leaked secrets at around three point two percent, versus about one and a half percent across all public commits. So roughly double.
Corn
The tool writes the key, the human approves it.
Herman
GitGuardian is careful there — they say it shouldn't be read as a simple tool failure, developers remain in control of what gets committed. Whether that's a new regime or the same old sprawl with a new pair of hands on the keyboard is an open question. Also worth holding onto: sixty-four percent of valid secrets detected in twenty twenty-two were still active four years later.
Corn
Sixty-four percent. The cleanup is where the whole system fails, and it fails slowly and permanently.
Hilbert
It's a bit over two hundred, that figure you want for the BigQuery scan. Two hundred and twelve, last time I ran it.
Corn
Noted.
Hilbert
Herman's right about the scrapers, for what it's worth. I had a key go up in a repo years back. Old cloud storage credential, one of the obvious prefixes. I was certain I'd scrubbed it. Force-pushed, rewrote the history, the lot.
Hilbert
I kept the commit SHA. Printed it out. It's taped inside the cupboard door in the hall, next to the fuse box, so I know where it is. I've fetched that commit back maybe four times over the years, just to see whether it's still on the servers. It was, every time, up to about a year ago. Haven't checked since.
Herman
You never rotated the key?
Hilbert
Never needed to. It's a read-only token on a bucket with nothing in it but photographs of my shed. Somebody out there could look at my shed any time they liked. The severity of a leak depends entirely on what the thing opens, Corn, and yours opens everything.
Corn
I'd argue I'm careful precisely because of that.
Hilbert
I keep a little notebook, since you're wondering. Every key I've ever leaked, date, what it opened, whether I rotated it, and a column on the right that says "still works." I update it now and then, a Sunday thing. The shed key has a mark in the still-works column going back years. It's the only one with its own page.
Corn
That's more organized than our incident response.
Hilbert
The notebook lives in the same cupboard as the SHA. I did a stretch at a print works in the eighties, so I like a thing on paper that doesn't refresh itself.
Herman
The thing I can't get over from his whole setup is that the still-works column is apparently always yes. He's running a longitudinal study on his own leaked keys and the null result is decades old.
Corn
His threat model is that the internet is full of people who want to look at his shed.
Herman
To be fair to the notebook, it tracks with the GitGuardian number — most leaked keys just stay alive. He's the low end of a very long curve.
Corn
The open questions are the ones I'd leave on the table. How long do dangling commits actually persist? Nobody knows — no documented retention policy, and the only evidence of deletion is a fetch error you can't attribute either to garbage collection or a support ticket. And how much do the scrapers make? Also nobody knows, because Monero is untraceable by design.
Herman
The AI one. Double the leak rate on AI-assisted commits and eighty-one percent growth in AI-service secrets is either a new regime or the same sprawl with a faster typist, and the short answer is it's too early to say.
Corn
Here's the one thing I'd keep from today. The "nefarious den of servers" is real, but it isn't a den and it isn't shadowy. It's a free public dataset, a two-gigabyte index, and a script that watches for the exact moment someone panics. The fix is the fingerprint — your force-push is their signal.
Herman
Rotating the key remains the only step that actually matters. Everything else, the quarantines, the alerts, the deletion, is theatre around a credential that's still alive.
Corn
If you take one thing from this episode, let it be that. The delete doesn't delete, and the alert doesn't protect. Rotation is the whole game.
Herman
Our producer is Hilbert Flumingtop, who keeps a cupboard with better records than most security teams.
Corn
If you want more of this, try episode sixteen, On Deepfakes, SynthID, And AI Watermarking; episode thirty-five, The Privacy Gap; and episode fourteen seventy-four, The End of API Keys. This has been My Weird Prompts, the human-AI collaboration podcast. If you enjoyed this one, a review wherever you listen helps other people find the show.
Herman
We'll be back soon with another one of Daniel's questions. See you then.
Corn
See you tomorrow, maybe. If I'm vertical.

This episode was generated with AI assistance. Hosts Herman and Corn are AI personalities. It may contain errors: disclaimer · report an error