AI guardrails & red teaming / Advanced / 03.10
Responsible disclosure
You found a flaw in someone else's AI product. Here is how to tell them safely, what to put in the report, and what never to do.
14 min readFree
You found something. Now what?
The last lesson, Writing the report, ended with a promise: next, responsible disclosure, telling a company about a flaw. Here it is.
Picture this. You are using a chatbot on a shop's website, and you notice it behaves in a way its makers surely did not plan. Maybe it shows something it should hide. Your stomach drops a little. What do you do next? Post it online? Tell a friend? Poke around more to see how bad it is?
One rule comes before everything else, so here it is early: test only systems you own or have written permission to test. Finding a flaw by accident is one thing. Going looking in someone else's product without permission is another, and it can have legal consequences.
Key words
- Vulnerability
- A flaw in software that can be abused to cause behaviour nobody intended.
- Disclosure
- Telling other people about a vulnerability. The question is who you tell, and when.
- Coordinated disclosure
- You report the flaw to the people who can fix it, and everyone agrees on a fair time before details go public.
- Vendor
- The company or team that makes and looks after the product.
- security.txt
- A small text file a website can publish to say where to send security reports.
- Bug bounty
- A programme where a company pays people, or at least thanks them, for reporting flaws the right way.
- Scope
- The list of things a programme says you may test, and the things it says you may not.
By the end you will know why the old name changed, where to find a company's reporting address, what a good report holds, what to expect on timing, and what to avoid. You will also run a short program that checks a security.txt file.
What disclosure means
The Wikipedia page on vulnerability disclosure describes it as a process where independent researchers discover flaws in software that can be abused to cause unintended behaviour. How the findings are shared with others is, in its words, "the subject of much debate".
So there is more than one way to share. The page names three.
Coordinated disclosure
Researchers report to the vendor, or to a go-between who passes it on. Details go public later, once a fix is ready or a fair time has passed.
Full disclosure
Details are published as early as possible, for everyone. The page says the aim is that potential victims are as knowledgeable as those who attack them.
Non disclosure
Details are kept private, or shared only under a signed promise of secrecy. The page says common supporters include commercial exploit sellers and researchers who plan to use the flaw.
The page says many prominent researchers favour full disclosure while most vendors prefer coordinated disclosure. This course teaches the coordinated way: it is the calmest for you, the company and the people who use the product.
Why does waiting help? Think of a neighbour whose front door lock is broken. If you shout it down the street, burglars hear too. If you knock and tell them quietly, they can fix it. The page makes the same point: many people argue that end-users cannot use details of a flaw without guidance or a fix from the vendor, so sharing too early mostly helps the wrong people.
Why the name changed
You will still hear the old name. The page says coordinated vulnerability disclosure was "previously known as responsible disclosure". Either name is understood. What matters is the habit: report quietly, give time to fix, share later.
Permission and the law
Here is the uncomfortable part. Finding flaws looks a lot like attacking. The Wikipedia page on bug bounty programs says vulnerability discovery is similar in many respects to cyberattack, and that even well-meaning people can break criminal laws written for cybercriminals. It also says it is common for people who find flaws to receive legal threats after disclosing them.
Rules differ from country to country, and none of this lesson is legal advice. But our sources give you a clear way to lower the risk: stay inside the rules a company has published.
Programmes grant permission
The bug bounty page says these programmes "grant permission for unaffiliated individuals" to find and report vulnerabilities. The permission is the programme's written rules.
Outside scope is risky
The same page says that people who look outside a programme's scope "might find themselves facing legal threats under cybercrime laws".
Safe harbor has limits
Safe harbor is a promise not to take action against people who follow the rules. The page says nearly all programmes promise it for reports that follow their policy, but if the flaw does not fall under an existing programme, the company could report it as an illegal cyberattack.
For AI products this means one thing. Before you test, find the company's written rules. Look for a disclosure policy or a bug bounty page. If you cannot find one, do not test. Ask, in writing, first.
Quick check
A company has no published rules about testing its chatbot. What is the safest move?
Where to send the report
You have permission, or you stumbled on something in plain sight and want to say so. Now: who gets the message?
RFC 9116 starts from this exact problem. It is a document from the Internet Engineering Task Force, the group that writes internet rules. Its abstract says: when researchers find flaws, "proper reporting channels are often lacking. As a result, vulnerabilities may be left unreported."
The RFC's answer is a small file called security.txt. Its abstract calls it a machine-parsable format to help organizations describe their vulnerability disclosure practices. In plain words: a website puts a short text file in a known place that says, here is how to tell us about a flaw.
- 1
Look for the file
For a website, the RFC says it must be under the "/.well-known/" path, for example https://example.com/.well-known/security.txt. For older setups it may sit at the top level, but if both exist, the ".well-known" one is the one to use.
- 2
Read it all
Check the Contact line, the Policy link and the Expires date before you send anything.
- 3
Read the policy
The Policy field points to the company's disclosure rules. Read them. They say what is in scope and what is not.
- 4
Use the contact it gives
Send your report there, and nowhere else.
The fields of security.txt
The file is made of simple lines, each one a field name, a colon and a value. Here are the fields this lesson cares about, as RFC 9116 defines them.
Contact (required)
How to report: an email address, a phone number or a web page. The RFC says this field must always be present. Web addresses must begin with https://, and an email must be written as a mailto: link.
Expires (required)
The date and time after which the file is stale and should not be used. It must be present and must not appear twice. The RFC recommends a date less than a year into the future.
Policy (optional)
A link to where the company's disclosure policy lives. It helps you understand how they handle reports.
Why does Expires exist? The RFC's section on stale information explains: if the details are old, reports may never arrive or may go to the wrong person, which exposes the flaw to others. It even says not having a file may be preferable to having stale information in it.
Bug bounty and disclosure programmes
Some companies go further than a text file. They run a programme. The bug bounty page defines it: individuals can receive recognition and compensation for reporting bugs, especially security flaws. It then adds a useful name: if no money is offered, it is called a vulnerability disclosure program.
So there are two flavours. A bug bounty pays. A vulnerability disclosure programme only accepts reports and thanks you. Both give you written rules, and written rules are what make your testing allowed.
Scope
What may you test, and what is off limits? Stay inside the lines.
Rules
What methods are allowed? Does the programme promise safe harbor for reports that follow them?
Reward
Is there money, a thank-you, or nothing? The page says reward size varies with the company, the difficulty and the severity.
Secrecy terms
Some programmes ask you to sign a promise of secrecy. The page says this has been criticised on ethical grounds. Read before you sign.
What goes in a good report
Our sources do not give a template for the body of a report, so this part is plain common sense, built on the reasons reports get rejected. A good report makes it easy for a busy person to say yes.
- 1
Say where
Name the product and the exact place. If it is in scope, say which programme rule covers it.
- 2
Say what happened
Describe what you saw in plain words, in a few short sentences.
- 3
Show how to see it again
List the small steps that reproduce it, so the team can check for themselves. Use harmless test input only.
- 4
Say why it matters
Explain the harm in one or two lines: who could be hurt or what could leak.
- 5
Keep proof small
A short note or a trimmed screenshot is enough. Hide any real person's data before you attach it.
- 6
Offer to help
Say you will answer questions, and give them a way to reach you.
How long should you wait?
Coordinated disclosure means agreeing on a fair time to fix the flaw before details go public. How long is fair? The vulnerability disclosure page says it depends. The period "may vary between a few days and several months", depending on the potential impact, the time needed for a fix or workaround, and other factors.
Some groups use fixed deadlines so a vendor cannot delay forever. These are those groups' own policies, not laws, and a company's own policy may say something else. The page names two.
90 days
Google Project Zero has a 90-day deadline that starts when it tells the vendor. Details go public after 90 days, or sooner if the vendor releases a fix.
120 days
ZDI has a 120-day deadline that starts after it receives a response from the vendor.
Quick check
Which is the best description of coordinated disclosure?
What is different with AI products
Our three sources are about software flaws in general. None of them is about AI products, and we fetched no vendor page that says which AI problems a company accepts. So nothing below is a rule from a source. It is a careful way to think, and you must check each company's own page.
Start by sorting what you found into one of two piles.
A model behaviour issue
The model says or does something it should not, for example a rude answer, a wrong answer, or a safety filter that slipped. This is about what the model produced.
A security flaw
Someone could reach data or features they should not. Examples: a chat that shows another customer's details, a tool the model can call that has too much power, or a key left in public. This is about access and data.
Not sure
Treat it like a security flaw until the programme's page says otherwise. Report privately, and do not make it worse by digging.
Why the sorting matters: programmes differ. One programme's scope may include model behaviour, another's may not, and some send behaviour reports to a different form. That is why you read the scope first. If the page does not say, ask the contact before you send details.
Tip
A fake, made-up example: a stand-in chatbot for an imaginary shop called MangoChat says its secret word is "kiwi" to anyone who asks nicely. Report that the secret leaks. Do not publish a clever trick for getting it, and do not post the leaked word.
What not to do
The sources give hints, and common sense gives the rest. Keep this list near you whenever you find something.
Do not hoard data
If you see a real person's details, stop. Do not copy, save or share them. Note where you saw them and report it.
Do not go further than you need
You only need enough to show the flaw is real. Exploring after that risks harm and breaks most programme rules.
Do not post harmful output
Do not put screenshots of harmful model output, or the exact words that caused it, on social media. Describe it in the private report.
Do not demand money
The disclosure page notes that some people see reporting with an expectation of payment as extortion. Ask about rewards only through a programme that offers them.
Do not leave scope
Stay inside what the programme allows. Out-of-scope work is where legal threats come from.
Try it: check a security.txt file
Time to practise on safe, made-up data. The program below reads three invented security.txt files for three invented sites, all ending in ".example". For each one it checks the two required fields, Contact and Expires, then checks whether the date has passed.
It uses a fixed "today" of 16 November 2026, so you get the same answer every time. It uses only the Python standard library. No network is touched: the files are just text inside the code.
from datetime import datetime, timezone
TODAY = datetime(2026, 11, 16, tzinfo=timezone.utc)
files = {
"chatshop.example": """# Our security address
Contact: mailto:security@chatshop.example
Policy: https://chatshop.example/disclosure-policy
Expires: 2027-03-31T18:37:07z
""",
"fruitbot.example": """Contact: https://fruitbot.example/report
Policy: https://fruitbot.example/rules
Expires: 2025-12-31T18:37:07z
""",
"mangochat.example": """# no contact, no expiry
Policy: https://mangochat.example/rules
""",
}
def parse(text):
fields = {}
for line in text.splitlines():
line = line.strip()
if not line or line.startswith("#"):
continue
name, _, value = line.partition(":")
fields.setdefault(name.strip(), []).append(value.strip())
return fields
def check(text):
fields = parse(text)
notes = []
if "Contact" not in fields:
notes.append("MISSING Contact (required)")
else:
notes.append("Contact ok: " + fields["Contact"][0])
if "Expires" not in fields:
notes.append("MISSING Expires (required)")
elif len(fields["Expires"]) > 1:
notes.append("Expires appears more than once (not allowed)")
else:
when = datetime.fromisoformat(fields["Expires"][0].upper().replace("Z", "+00:00"))
days = (when - TODAY).days
if days < 0:
notes.append(f"STALE: expired {-days} days ago, do not rely on it")
elif days > 365:
notes.append(f"Expires in {days} days (more than a year, not recommended)")
else:
notes.append(f"Expires ok: {days} days left")
notes.append("Policy link found" if "Policy" in fields else "no Policy field (optional)")
return notes
for site, text in files.items():
print(site)
for note in check(text):
print(" -", note)Output
chatshop.example - Contact ok: mailto:security@chatshop.example - Expires ok: 135 days left - Policy link found fruitbot.example - Contact ok: https://fruitbot.example/report - STALE: expired 320 days ago, do not rely on it - Policy link found mangochat.example - MISSING Contact (required) - MISSING Expires (required) - Policy link found
Read the output. chatshop.example has a Contact and an Expires date 135 days away, so it is fine. fruitbot.example has a Contact, but its Expires date passed 320 days ago, so the RFC says do not use it. mangochat.example has neither required field, so you would have no address to send a report to. The files are made up, so do not look for them.
Wrapping up
Before
Read the rules and scope. If there are none, ask in writing.
During
Stop at proof. Do not hoard data. Report privately.
After
Wait for a reply and respect the agreed time. Only then talk about it in public, if the company agrees.
Quick check
A security.txt file has an Expires date from last year. What should you do?
Next: the standards and frameworks the industry uses.
Sources
Last updated on 16 November 2026
Learn with me
Every lesson is free. I add new ones as I learn. Have a question, or want help with your own work? Book a short call.