# Who Scrapes Leaked API Keys from GitHub?

My Weird Prompts — an AI-generated podcast. Daniel Rosehill sends in a prompt; AI hosts Corn and Herman discuss it. Verify important claims independently.

- Episode: 6741
- Published: 2026-11-22
- Duration: 30:14
- Audio: https://episodes.myweirdprompts.com/audio/scraped-api-keys-github-87268.m4a
- Tags: open-source, cyberattacks, devops, ai-security, cloud-computing
- Web page: https://myweirdprompts.com/episode/scraped-api-keys-github-87268/
- JSON: https://myweirdprompts.com/api/episodes/scraped-api-keys-github-87268.json

## Summary

Accidentally pushing an API key to a public GitHub repository triggers a desperate race between deletion and compromise. Automated scanners find exposed credentials in under a minute, turning momentary developer blunders into active compromises before a git history can be rewritten. Explore how attackers index real-time public commits, why AWS quarantine policies leave subtle security holes open, and the surprising speed discrepancy between pull requests and issue comments.

## The prompt

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

## Show notes

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

- [GitHub Docs, Push protection, retrieved 2026-11-22](https://docs.github.com/en/code-security/concepts/secret-security/push-protection)
- [GitHub Docs, Secret scanning, retrieved 2026-11-22](https://docs.github.com/en/code-security/concepts/secret-security/secret-scanning)
- [GitHub Docs, Secret scanning detection scope, retrieved 2026-11-22](https://docs.github.com/en/code-security/reference/secret-security/secret-scanning-scope)
- [GitHub Docs, About secret scanning alerts, retrieved 2026-11-22](https://docs.github.com/en/code-security/concepts/secret-security/about-alerts)
- [GitHub Docs, Enabling push protection for your repository, retrieved 2026-11-22](https://docs.github.com/en/code-security/secret-scanning/enabling-secret-scanning-features/enabling-push-protection-for-your-repository)
- [Meli, McNiece, Reaves, How Bad Can It Git? Characterizing Secret Leakage in Public GitHub Repositories, NDSS 2019, retrieved 2026-11-22](https://doi.org/10.14722/ndss.2019.23418)
- [Truffle Security, Dylan Ayrey, The Anatomy of a GitHub Secret Leak: From Commit to Compromise, 2026-02-20, retrieved 2026-11-22](https://6ca3965f-6a12-417a-86b7-9a34473c43d1.trufflesecurity.com/research/secret-detection/anatomy-github-secret-leak-commit-to-compromise)
- [Clutch Security, Shattering the Rotation Illusion: Part 1, 2024-12-03, retrieved 2026-11-22](https://www.clutch.security/blog/shattering-the-rotation-illusion-part-1-code-hosting-and-version-control-platforms)
- [Unit 42, CloudKeys in the Air: Tracking Malicious Operations of Exposed IAM Keys, 2023-10-30, retrieved 2026-11-22](https://unit42.paloaltonetworks.com/malicious-operations-of-exposed-iam-keys-cryptojacking/)
- [Truffle Security, How to Scan Force Pushed Commits for Secrets, retrieved 2026-11-22](https://trufflesecurity.com/blog/how-to-scan-force-pushed-commits-for-secrets)
- [GitGuardian, State of Secrets Sprawl 2025, 2025-03-11, retrieved 2026-11-22](https://www.gitguardian.com/state-of-secrets-sprawl-report-2025)
- [GitGuardian blog, The State of Secrets Sprawl 2025, 2025-03-11, retrieved 2026-11-22](https://blog.gitguardian.com/the-state-of-secrets-sprawl-2025/)
- [GitGuardian, The State of Secrets Sprawl 2026, retrieved 2026-11-22](https://www.gitguardian.com/state%2Dof%2Dsecrets%2Dsprawl%2Dreport%2D2026)
- [GitGuardian blog, The State of Secrets Sprawl 2026, retrieved 2026-11-22](https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/)
- [GitHub, smakarim/revenant, retrieved 2026-11-22](https://github.com/smakarim/revenant)
- [GitHub, chrisns/example-orphaned-commit-repo, retrieved 2026-11-22](https://github.com/chrisns/example-orphaned-commit-repo)
- [AWS Builder Center, From git push to crypto miner in 5 minutes, retrieved 2026-11-22](https://builder.aws.com/content/3LiNfTk0pLkf4obFelQ0c74g24g/from-git-push-to-crypto-miner-in-5-minutes-what-really-happens-when-an-aws-key-leaks-on-github)
- [Carter Appleton, Your Secrets Are Still on GitHub, retrieved 2026-11-22](https://carterappleton.com/blog/github-secret-scanning/)
- [The Hacker News, The State of Secrets Sprawl 2026: 9 Takeaways for CISOs, 2026-03, retrieved 2026-11-22](https://thehackernews.com/2026/03/the-state-of-secrets-sprawl-2026-9.html)
- [Passwork, The state of secrets sprawl in 2026, retrieved 2026-11-22](https://passwork.pro/blog/the-state-of-secrets-sprawl-in-2026/)
- [The Register, Cryptojackers steal AWS credentials from GitHub in 5 minutes, 2023-10-30, retrieved 2026-11-22](https://www.theregister.com/security/2023/10/30/cryptojackers_steal_aws_credentials_from_github_in_5_minutes/522761)
- [Neodyme, Hidden GitHub Commits and How to Reveal Them, retrieved 2026-11-22](https://neodyme.io/blog/github_secrets/)

## Transcript

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.
