# The Third-Party Leaked-Secret Handoff: Public Commit to Confirmed Rotation

*Take one exposed string and its commit URL to a named owner, a notice that never reveals the secret, and a dated rotation record or escalation by day 21.*

- Canonical URL: https://www.refolk.ai/guides/third-party-leaked-secret-handoff
- Pillar: Engineering and open source
- Format: Playbook
- Published: 2026-11-17
- Last reviewed: 2026-11-17
- Reading time: 20 min
- Keywords: found api key in someone else's github repo, how to report a leaked credential to a company, security.txt contact not responding, responsible disclosure leaked secret third party, who to notify about exposed token in public repo

## Key takeaways

- Never authenticate with a credential you found in someone else's repository: the DOJ's good-faith CFAA policy only governs federal charging decisions and has no effect on civil CFAA liability or state laws.
- A GitHub partner-pattern match does not mean the leak is handled, because AWS quarantines an exposed key within about 10 seconds but leaves it active, and Volcengine only sends an email.
- Generic secrets make up 58% of leaked credentials and have no issuer pattern, so for most leaks the finder's report may be the only notice the owner ever gets.
- Valid security.txt adoption among the top million domains has been measured between 0.49% and 1.25%, and 18% of files in one study had already expired, so check the Expires date before sending.
- In Refolk's index, a US title search for PSIRT, Vulnerability Disclosure, or Bug Bounty Program roles returned 1 profile, and it was a false match, against 454 Product Security Engineers.
- Close every case with one dated record: written confirmation of rotation, the secret removed from HEAD, or a CERT/CC case number, with day 7 and day 21 as the follow-up and escalation points.

This playbook is for the person who finds another organization's live-looking credential in a public repo, gist, or package. That might be an engineering manager reviewing a dependency, a developer-relations lead triaging a fork, or a technical sourcer reading code. It takes you from one exposed string and its commit URL to a named owning organization, a notice that does not reveal the secret, and a dated case record that ends in confirmed rotation or a documented escalation by day 21. Most writing on leaked secrets is for owners who leaked their own keys. This guide is for the finder.

## What a finder may and may not do with a found credential

You may record, attribute, and report the exposed secret. You may not use it, and that includes "just checking whether it works." Every step in this playbook is built around that line.

I understand the temptation. A format match does not prove a key is live, and one authenticated call would settle the question. One practitioner states the problem plainly: "Testing a key you found in someone else's repository is using someone else's credentials, whatever the reason."

The legal cover people point to is narrower than it sounds. The US Justice Department's charging policy under the Computer Fraud and Abuse Act (CFAA, the main US federal computer-intrusion statute) protects access done "solely for purposes of good-faith testing, investigation, and/or correction of a security flaw or vulnerability" when it is carried out in a way designed to avoid harm. Three limits apply:

- **It is a charging policy, not a safe harbour.** It has no effect on civil CFAA liability or state laws.
- **Good faith is not a free pass.** DOJ said it would scrutinize whether conduct is consistent with a claim of good faith.
- **It governs prosecutors.** They must consult DOJ's Computer Crime and Intellectual Property Section (CCIPS) before bringing charges. Nothing in that process protects you from a lawsuit.

No source I can cite rules explicitly on whether authenticating with a found key falls inside the policy. I have not researched non-US equivalents. If you work outside the US, check your own jurisdiction before you do anything beyond reading public pages.

> **Rule:** Never authenticate with a found secret
>
> Do not use the key to test it, to check its scope, or to prove to a skeptical recipient that it is live.
> Confirm by inspection only: the file path, the surrounding code, and whether HEAD still contains the string.

Not testing the key does not make the leak less urgent. Microsoft Threat Intelligence observed an agent called ARTEX find OAuth application secrets on public GitHub, sign in as a service principal, and exfiltrate Key Vault data in five minutes. Leaks also stay open for a long time:

**64% - Share of previously confirmed-valid leaked secrets still valid years later**

GitGuardian retested secrets it had confirmed valid. Nearly 70 percent still worked at the first retest, and more than 64 percent at the second.

## Has GitHub already told the issuer about this secret?

Only if the string matches a secret scanning partner pattern. Even then, the issuer's response ranges from automatic revocation to a single email. Classify the format before you assume someone else is handling it.

GitHub's partner program works like this. When GitHub detects a secret in a public repository or npm package, it sends an alert directly to the issuer (the company that minted the credential), provided that issuer is a partner. Partner alerts are not sent to repository administrators. Non-partner "user" patterns, such as the keys to a self-hosted HashiCorp Vault, only produce alerts for the repository's owner and never reach an issuer. GitHub has said it scans for more than 200 token formats, and it adds detectors over time (a Cloudflare access service token detector is one example). Check GitHub's current supported-patterns list for every case instead of relying on memory.

Label each string with one of three classes:

- **Partner:** GitHub has probably notified the issuer. What happened next depends on the issuer.
- **User-alert-only:** only the repo owner may have been alerted, and only if they have alerts turned on.
- **Generic:** no known pattern. Nobody has been told unless you tell them.

The issuer's action is the part people get wrong. These are the documented responses to a public-repo match:

| Issuer | Action on a public-repo match | What it means for you |
|---|---|---|
| GitHub PAT | Auto-revoke | Courtesy notice to owner |
| AWS | Quarantine policy, key stays active, support case | Owner must still rotate |
| Anthropic | Deactivate and email user | Confirm with owner |
| Volcengine | Email only, no token change | Treat as unreported |
| Resend | Revoke or notify | Unknown which; report |

Nobody has published a complete per-issuer table showing which issuers revoke, which only email, and which do nothing. For an issuer not listed here, read its own documentation, and if it says nothing, assume no action.

> **Watch out:** Quarantine is not revocation
>
> In Unit 42's test, AWS attached the AWSCompromisedKeyQuarantineV3 managed policy within 10 seconds of a test key being pushed, then sent a Health notification, an email, and a support case within the same minute. The key still stayed active. Report to the owner anyway.

The larger gap is generic secrets. GitGuardian counted 28.65 million new hardcoded secrets in a single year, and found that generic secrets accounted for 58% of all leaked credentials. A generic secret matches no issuer pattern, so no partner alert fires. For most of what you will find, your report may be the only notice the owner ever gets.

## Attributing a leaked secret to an owning organization

Attribute from public evidence you can cite: verified domains, org membership, package publisher, fork parent, and commit email domain, roughly in that order of strength. Then cross-check against what the surrounding code says the key opens. The output is a named organization plus a written confidence note, and you should never skip the note.

There is production precedent for the top two signals. GitHub's enterprise public-monitoring feature attributes leaks using GitHub-specific signals such as enterprise membership and verified domains. Every signal can mislead you, though, and the most common error is treating the committer's employer as the key's owner.

| Signal | What it proves | How it lies |
|---|---|---|
| Verified domain on the org | Org controls the domain | Key belongs to a client of the org |
| Committer's org membership | Committer works with the org | Contractor pushing a client's key |
| Package publisher | Who ships the artifact | Vendored code carries another's key |
| Fork parent | Where the code came from | Fork owner added the key, not the parent |
| Commit email domain | Committer's likely employer | Personal address, or employer is not the owner |
| Hosts or account IDs in nearby config | Which system the key opens | Example values copied from documentation |

#### Attribution evidence, strongest first

1. **Verified domain and org ownership** - The organization controls the repo or domain where the secret sits
2. **Org membership and package publisher** - The committer or publisher is formally tied to the organization
3. **Fork parent** - The code originated with an upstream owner who may hold the key
4. **Commit email domain** - The committer's probable employer, which may not own the key
5. **Hosts and IDs in surrounding code** - What the key appears to open, read by inspection only

*Attribute from the top layer down, and treat any disagreement between layers as a reason to lower confidence, not to pick a winner.*

Contractors and personal forks cause the most trouble. A contractor's personal fork can carry a client's key, and the commit email will point at the contractor's own company. Cross-check the hostnames, account identifiers, or tenant names that appear near the secret against the fork parent and the package publisher. The rate at which committer and owner differ has not been published. Leaking is common in either case: GitGuardian reports that 15% of commit authors leaked a secret.

Write the confidence note as High, Medium, or Low, and list which signals agree. "High: verified domain, org membership, and the config hostname all name the same company" is a usable note. "Probably theirs" is not. The note tells you how widely to send. With a Low note, send to more than one route and say in the notice that you are not certain of ownership.

Once you have an organization, you need a person there. [Refolk](/) is useful at this point: ask for engineering managers at the company that owns a verified domain, or for security engineers who maintain the packages a company publishes, and you get named people instead of a contact@ guess.

## Which reporting route to use, and in what order

Go to the issuer first. Then use the owner's published security channel, contact the committer privately in parallel or as a fallback, try the parent company if the owner is a subsidiary with no channel, and use a coordinator such as CERT/CC last. Each route has a timebox and a definition of done.

#### Reporting route order

1. **Issuer** - File through the issuer's abuse or leaked-key route and get a ticket ID
2. **Owner security channel** - Use a valid security.txt Contact or Policy URL, or a named security person
3. **Committer, privately** - Email the address on the commit, never through a public issue
4. **Parent company** - Use the parent's security channel when the subsidiary has none
5. **Coordinator** - Escalate to CERT/CC or the relevant CNA on day 21

*Run the routes in this order, and do not stop at the issuer, because issuer action ranges from revocation to a single email.*

| Route | Use when | Done looks like |
|---|---|---|
| Issuer | Issuer runs an abuse or leaked-key route | Ticket ID |
| Owner's security channel | security.txt is unexpired, or a Policy URL exists | Notice sent |
| Committer, privately | Commit email is visible | Dated private message |
| Parent company | Owner has no channel of its own | Notice sent to parent |
| Coordinator | No response by day 21 | Case number |

The committer route is where published advice disagrees. One practitioner reported opening "polite, constructive GitHub Issues" on affected repositories. I don't recommend it. A public issue points everyone watching the repository at the secret, which breaks the first requirement of the job: don't make the leak worse. If a public issue really is the only way to reach anyone, it should ask for a private security contact and nothing else. Leave out the file, the secret type, and the commit.

Your urgency depends on two things: whether the issuer has already killed the key, and how sure you are of the owner.

#### Urgency by issuer action and attribution strength

Horizontal axis runs from Issuer did nothing or only emailed to Issuer revoked the key. Vertical axis runs from Weak or conflicting attribution to Named owner, strong evidence.

| Quadrant | What it means |
| --- | --- |
| Owner is the only fix | Send to the security channel or a named product security engineer today |
| Confirm and close | Notify the owner so they rotate anything that depended on the key |
| Hardest case | Spend the full attribution hour, email the committer privately, start the clock |
| Issuer has it | Log the ticket ID and keep attributing for a courtesy notice |

*The owner is the only fix when the issuer did nothing, so the top-left quadrant gets sent today.*

## Finding a person when security.txt is missing or stale

Check security.txt, but expect it to fail. Measured valid adoption among the top million domains runs from 0.49% to 1.25%, and many of the files that do exist are expired or non-conformant. The route that usually works is a named person in an adjacent security role.

security.txt is a plain-text file at `/.well-known/security.txt`, defined by RFC 9116, that tells researchers how to report security issues. The RFC requires only two fields:

- **Contact:** at least one. In the URIports sample, 67% use email, 31% a URL, and a rare 2% list a telephone number.
- **Expires:** it must always be present and must not appear more than once.

Optional fields include Policy, which links to the vulnerability disclosure policy, and Preferred-Languages. If Preferred-Languages is missing, you may assume English.

| Study | Scope | Adoption | Compliance or expiry |
|---|---|---|---|
| Findlay and Abdou | Top 1M | 0.49% valid | About half of top-ranked files expired |
| security.txt Revisited (ACM) | Top 1M, 55 weeks | About 1% | At least two-thirds non-conformant |
| URIports | Top 1M | 0.7% | 19% compliant, 18% expired |
| URIports re-measure (secondary) | Top 1M | 1.25% | 44% compliant |

The Expires field causes the most damage. URIports found that 46% of files did not specify it, 4% showed invalid values, and 18% had already expired. A file past its Expires date is the owner telling you the contact may be dead. You can still use it, but treat it as unconfirmed and send to a second route at the same time.

If there is no valid file, you will need a name, and dedicated disclosure-handler job titles barely exist:

**1 - US profiles titled PSIRT, Vulnerability Disclosure, or Bug Bounty Program in Refolk's index**

That single match was a false positive, an infrastructure engineer, against 454 US profiles titled Product Security Engineer.

| Title searched | Market | Profiles in Refolk's index |
|---|---|---|
| Product Security Engineer | US | 454 |
| Product Security Engineer | UK | 48 |
| PSIRT, VDP, or Bug Bounty Program titles | US | 1 (false match) |

Searching for a "vulnerability disclosure manager" will return almost nothing, so route by adjacency instead. Refolk's index has 9.5 times as many US Product Security Engineers as UK ones, and in a 25-profile sample Meta and Apple appear among the top employers of the title in both markets. That sample is too small to generalize from, but it suggests the title clusters at large companies. For smaller owners, go down this ladder:

1. Product security engineer at the owning organization.
2. Head of security or CISO.
3. Engineering manager of the team that owns the repository or package.
4. Members of the organization's GitHub org account who mention security in their profile.

Refolk handles this lookup in plain English, which matters when you are holding a live leak and the security.txt file returns a 404:

I ran this search: `Product security engineers currently at Smartsheet or Chime` - [see the full result list](https://www.refolk.ai/s/mbj6s9455t).

*Returns named product security engineers at those two companies, with profile links to check against before you send the notice.*

## The handoff procedure, step by step

Eight steps take about two hours of your time on day one, followed by fixed checkpoints on day 7 and day 21. The step order and timeboxes are assembled from several published sources. No single published standard covers the whole sequence.

#### Public commit to confirmed rotation

1. **Preserve the evidence without testing** - Spend 10 to 15 minutes recording the commit URL, SHA, file path, commit timestamp, and a hash or masked fragment of the secret, and never authenticate with it. Done is a dated evidence note with no full secret in it.
2. **Classify the secret format** - Spend about 10 minutes checking the string against GitHub's supported secret scanning patterns and labeling it partner, user-alert-only, or generic. A partner label means the issuer was probably told, not that the key is dead.
3. **Attribute the owning organization** - Spend 30 to 60 minutes checking verified domain, org membership, package publisher, fork parent, and commit email domain, then cross-checking against hosts or IDs in the code. Done is a named organization plus a confidence note.
4. **Report to the issuer** - Where the issuer runs an abuse or leaked-key route, spend about 15 minutes filing there with the commit URL and masked fragment. Done is a ticket ID.
5. **Notify the owner's published security channel** - Spend about 30 minutes fetching /.well-known/security.txt, confirming Expires is in the future, and using its Contact or Policy URL, or a named security person if there is none. Done is a sent notice that does not contain the secret.
6. **Write the committer privately** - In parallel or as a fallback, email the address on the commit and never use a public issue. Done is a sent private message with its date logged.
7. **Follow up on a fixed clock** - On day 7 with no response, resend to the same address and copy a second contact. On day 21 with no response, escalate to CERT/CC or the relevant CNA.
8. **Close the case with a dated record** - Close on written confirmation of rotation, on the secret being removed from HEAD, or on a coordinator case number, rechecking by inspection only. Done is a dated closure entry naming which of the three you have.

The follow-up clock comes from one published researcher timeline built for general vulnerability disclosure. A leaked credential is more urgent than most vulnerabilities, so treat day 21 as the outer limit, not the target. A CNA is a CVE Numbering Authority, an organization authorized to assign CVE identifiers for products within its scope.

The notice below carries everything the owner needs to find and rotate the secret, and nothing an attacker could use.

**Leaked-credential notice to the owning organization**

```
Subject: Exposed credential in a public repository attributed to [Organization]

Hello,

I found what appears to be a credential belonging to [Organization] in a public location:

- Location: [commit URL]
- Commit SHA: [SHA]
- File path: [path]
- Committed: [commit timestamp]
- Apparent type: [e.g. cloud access key / API token / generic secret]
- Masked fragment: [prefix]...[last few characters]
- First observed by me: [date and time, with timezone]

Why I believe it is yours: [one line from your confidence note].

I have not used, tested, or authenticated with this credential, and I have not shared it publicly.
I have also notified [issuer, ticket ID / nobody yet].

Please rotate the credential rather than only deleting the file, because the commit above stays reachable.
Could you reply to confirm receipt, and confirm once it has been rotated?

If this is not yours, or reached the wrong team, a pointer to the right contact would be appreciated.

[Name]
[Contact details]
```

*Fill in the bracketed fields from your evidence note; never paste the full secret anywhere in this message.*

## How this goes wrong: failure modes and false positives

Most failed handoffs come from seven mistakes. Some are false positives that waste the owner's time. Others are false comforts that leave the key live. Read this section before you send anything, because several of these mistakes cannot be undone once the notice is out.

### A format match mistaken for a live key

The string may be a test fixture, a documentation example, or a key that was revoked long ago. Check the file path for `/test`, `/example`, or a README, and check whether HEAD still contains the string. If the evidence is ambiguous, say so in the notice. Never settle the question by authenticating.

### Assuming a partner pattern means the leak is fixed

A partner match tells you an alert went to the issuer. It tells you nothing about what the issuer did with it. AWS quarantine leaves the key active, and Volcengine sends an email and changes nothing. Report to the owner anyway, and record the issuer's documented behavior in the case file so the owner knows what has and has not happened.

### The committer's employer taken as the owner

A contractor's commit, or a personal fork, can carry a client's key, and the commit email will point at the wrong company. Cross-check the key's apparent host or scope, read from the surrounding code, against the fork parent and the package publisher. The mismatch rate has not been published, so do not assume it is rare.

### Trusting a stale security.txt

In the URIports sample, 18% of files had already expired. An expired file usually points to an inbox nobody reads. Check Expires before sending, and when it is past, send to a named person at the same time.

### A public GitHub issue as the notice

An issue re-advertises the secret to everyone watching the repository, and to anyone scraping it. Use private channels first. If a public issue is your only option, it should ask for a private contact and give no detail.

### The full secret in the email body

The notice turns into a second leak, stored in mail servers, ticket systems, and forwards you do not control. Send the commit URL, SHA, path, and a masked fragment. Those are enough to identify the credential.

> A notice that contains the secret is not a report. It is the second leak.

### Escalating to CERT/CC as if it guarantees action

CERT/CC may decline to coordinate or publish a report at its discretion. Its default deadline is publication 45 days after the initial report, regardless of whether patches exist. That clock was built for software vulnerabilities and may not suit a credential that the owner can rotate in minutes. Escalate to keep a record and to apply pressure, not because you expect a guaranteed fix.

## Closing the case and keeping the method current

A case closes on one of three dated records: written confirmation of rotation, the secret removed from HEAD, or a coordinator case number. Recheck by inspection only. Never test the old key to see whether rotation worked.

The three records differ in strength:

| Closure record | Strength | Why |
|---|---|---|
| Written confirmation of rotation | Strongest | The owner states the credential is dead |
| Secret removed from HEAD | Weaker | The recorded commit stays reachable; the key may still work |
| CERT/CC case number | Closes your side | Documents escalation, not a fix |

When you need to escalate, reports to CERT/CC go in through its Vulnerability Reporting Form (VRF). CERT/CC does not publish a first-response time, so log the date you submitted and do not promise the owner, or yourself, a response window. I have not researched national CSIRT response times, GitHub's own sensitive-data or abuse route, or bug bounty platforms' disclosure assistance. Verify any of those against their own published policies before you rely on them.

Keep one record per case, written as you go and not reconstructed afterwards:

**Leaked-secret case record**

```
Case ID:
Evidence: commit URL | SHA | file path | commit timestamp | masked fragment or hash
Classification: partner / user-alert-only / generic  (checked against pattern list on: date)
Owner: organization | confidence High/Medium/Low | signals that agree | signals that conflict
Routes:
  [date] Issuer: route used | ticket ID
  [date] Security channel: security.txt Expires date | Contact or Policy used
  [date] Named person: name, title | how found
  [date] Committer (private): address
Follow-ups:
  [day 7 date] Resent to | second contact copied
  [day 21 date] Escalated to CERT/CC or CNA | case number
Closure: [date] rotation confirmed / removed from HEAD / coordinator case | evidence link
Never used or authenticated with the credential: yes
```

*One record per string; append dated lines, never edit earlier ones.*

#### Before you call the case closed

- [ ] The evidence note and every message sent contain only a masked fragment or hash, never the full secret.
- [ ] No one on your side authenticated with, tested, or scoped the credential at any point.
- [ ] The secret's class was checked against GitHub's current supported-patterns list, and the check date is logged.
- [ ] The owning organization is named, with a High, Medium, or Low confidence note that lists the agreeing signals.
- [ ] The issuer route was used where one exists, and its ticket ID is recorded.
- [ ] The security.txt Expires date was checked before any notice went to its Contact.
- [ ] No public issue, comment, or post disclosed the location or type of the secret.
- [ ] The day 7 follow-up and, if needed, the day 21 escalation happened on schedule and are dated.
- [ ] The closure entry states which of the three closure records you hold and links the evidence.

Some inputs to this method change over time, so recheck them on each case. GitHub adds detectors and partners, so a string that was generic last quarter may be a partner pattern now. Issuers change what they do with partner alerts, so recheck the issuer's documentation before telling an owner what has already happened. security.txt files expire by design, so read the Expires field fresh every time. The method itself should not drift: never authenticate, never publish, send the notice privately, and keep a dated record of how each case closed.

## Frequently asked questions

### Is it legal to test whether an API key I found in someone else's GitHub repo works?

Treat it as off limits. Authenticating with a found key means using someone else's credentials. The DOJ's good-faith research policy only shapes federal charging decisions. It has no effect on civil CFAA liability or state laws, and DOJ has said good faith is not a free pass. No source rules clearly on authenticating with a found key, and non-US law was not researched. Confirm by inspection instead: check the file path, the surrounding code, and whether HEAD still contains the string.

### Does GitHub already notify the company when a key leaks in a public repo?

Only when the key matches a secret scanning partner pattern. In that case GitHub sends the alert to the issuer, not to the repository admins. What the issuer does next varies: GitHub revokes its own PATs, AWS attaches a quarantine policy but leaves the key active, and Volcengine only emails the user. Generic secrets, 58% of leaked credentials, have no issuer pattern at all. Report to the owner either way.

### What do I do if the security.txt contact is not responding?

Start with the Expires field, because 18% of files in one study had already expired and the contact may be dead. If there is no reply by day 7, resend to the same address and copy a second contact, such as a named product security engineer or head of security. If there is still nothing by day 21, escalate to CERT/CC or the relevant CVE Numbering Authority and record the submission date.

### Should I open a GitHub issue to tell the repo owner about the exposed token?

No, not as the notice. A public issue points everyone who watches the repository at the secret. Use the issuer's route, the owner's security channel, a named security person, or the committer's email first. If a public issue is your only way to reach anyone, ask only for a private contact for a security matter. Leave out the file, the secret type, and any detail.

### Should I include the leaked key in my report to the company?

No. The commit URL, SHA, file path, and a masked fragment are enough for the owner to find the string. A notice that contains the full secret becomes a second leak. It sits in mailboxes, ticket systems, and forwards that you do not control. The masked fragment lets the recipient confirm they have the right credential without you sending a usable copy.

### What counts as proof that a leaked secret was rotated?

The strongest proof is written confirmation from the owner that the credential was rotated, with a date. Removal of the secret from HEAD is weaker, because the commit you recorded can still be reached, and deleting a file does not invalidate a key. A CERT/CC case number closes your side when the owner never responds. Verify by inspection only. Never test the old key to see whether it still works.

---

*From the Refolk guide library. I revise these guides rather than replacing them, so the current version is always at https://www.refolk.ai/guides/third-party-leaked-secret-handoff*
