Bugbounty for Government backdoors

Discussion & Solutions
1

Bug Bounty for Government Backdoors

Hi everyone,

This is my first post here, so I wanted to start with something that has been on my mind for a while.

In my opinion, credibility is often used to influence or manipulate public opinion and even the law.

Today, in many countries, we can watch live debates, parliamentary sessions, and voting on important national issues. Since politicians make decisions that affect all of us, I started wondering:

Can we automatically verify whether public statements made by politicians are true or misleading?

My Project

I built a simple Chrome extension.

The idea is straightforward:

  • While watching a live debate, if the system detects that a politician is making a false or misleading statement, a red box appears on the screen.
  • The box shows the type of misinformation or logical fallacy, along with a short explanation of why it was flagged.

The project originally started with a very simple approach.

I used a locally hosted Ollama 3.0 model that only monitored subtitle changes in the webpage’s DOM. As subtitles appeared, the model analyzed them using scientific methodologies designed to reduce bias and emotional reasoning when evaluating claims.

The goal was never to attack political opinions. It was simply to encourage evidence-based thinking.

Naturally, many additional features came to mind after that.

The Legal Problem

Then the EU introduced regulations stating that employers generally cannot use AI systems to monitor employees in the workplace.

I think that makes sense for private companies.

However, politicians are different.

If I vote for someone, that person represents me and my interests while acting as a public official during working hours.

Shouldn’t citizens be allowed to verify whether those public statements are accurate?

Unfortunately, depending on where you live and how such software is used, trying to build or distribute tools that automatically evaluate politicians’ statements may raise legal concerns.

Because of that, I will not publish the repository.

I’m not interested in creating legal problems for myself.

Instead, I’ll simply share observations and research.

Possible Technical Directions

There are many interesting research areas related to this idea.

For example:

  • Psychological, neurocognitive, and medical research discussing whether deception can be detected from behavior or body language.
  • Historical archives and knowledge bases that can verify whether someone is misquoting another person or putting words into someone else’s mouth.
  • Replacing fragile DOM monitoring with speech transcription using Whisper.
  • Using multiple LLMs instead of a single model to reduce false positives.
  • Allowing the AI to delay judgment until additional context is spoken, assigning a confidence percentage before showing a warning instead of immediately displaying a false red flag.

The objective is not to declare someone a liar instantly.

The objective is to estimate the probability that a claim is misleading while minimizing false accusations through additional context and verification.

I still believe a simple sentence says it best:

“Friends don’t lie.”

P34C3

2

You built it already. Everything you’re still missing is sitting on GitHub, free, in pieces.

Nobody has bolted the pieces together yet. That’s the whole gap.

Map below. Open only what you need. :bullseye:

☠️ The graveyard — 4 teams already tried live debate fact-checking. Their failure notes.
  • Squash — the 12-year post-mortem — Duke did your exact idea: hear the claim, pop a verdict on screen in seconds. Then listed every reason it hurt. Read before writing another line.
  • FactPopUp — 2016 Chrome extension that fired fact-checks over a live debate using only browser notifications. Crude. Worked.
  • ClaimBuster — scores a sentence for whether it’s even worth checking. 164M+ API calls served.
  • ClaimBuster API — free, documented. Send sentence → get score.
  • claimbuster-spotter — the model itself, to run local.
  • ClaimPortal — spot-the-claim + find-existing-fact-check, already wired together.
🎙️ Your DOM subtitle hack is duct tape — here's the audio route, prebuilt

DOM = the live structure of a webpage. It breaks on every site redesign. You already knew. So:

  • antor44/Audio-Transcription — Chrome extension: grabs tab audio → local Whisper → live overlay. Falls back to page subtitles. This is your spine, already built.
  • collabora/WhisperLive — the local Whisper server it plugs into. Ships browser extensions, hotword boosting, live speaker diarization (= who’s talking right now).
  • xenova/whisper-web — Whisper fully inside the browser. No server, nothing leaves the machine.
  • browser-whisper — only transcribes when someone actually speaks. Saves your CPU during applause.
  • whisper-web-transcriber — solves the browser security headers that break in-browser Whisper. Saves a weekend.
🧠 Don't build the verify-a-claim brain — 5 open ones exist, and one eats video
  • Loki — splits text into single claims → scores them → writes its own search queries → crawls evidence → verdict. Takes speech and video files directly.
  • HerO — full open-model pipeline, 2nd place in an international claim-verification contest. Your flowchart, with code.
  • HerO 2 — verifies a claim in under 60 seconds. Your real-time budget, already met.
  • AIC CTU — the minimal version. RAG = fetch documents first, answer only from them.
  • OpenFactCheck — claim-splitter / evidence-fetcher / verdict-giver as 3 swappable slots. Your multi-model comparison, prebuilt.
  • Live leaderboard — see what’s winning before you pick an architecture.
  • Master index of the whole field — every paper that matters.
🎯 The one tool that stops you accusing an innocent man (sub-1B, GPT-4 accuracy)

Your red box is only as honest as one question: does the evidence actually say that, or did the model vibe it?

  • MiniCheck — give it a document + a claim, it says if the document truly backs the claim. GPT-4 level in a model under 1B params, ~400x cheaper. Runs next to your Llama. Take this link if you take nothing else.
  • LLM-AggreFact — 11 datasets, one scoreboard. Prove it works instead of hoping.
  • awesome-hallucination-detection — every “is the model making it up” detector, maintained.
🧨 A fallacy detector that LISTENS to the voice — trained on 60 years of debates

Text + audio together. Because the sneer lives in the delivery, not the transcript.

  • MAMKit — toolkit: 4 datasets, 6 model setups. Detects fallacies, classifies which one, spots claims, maps who attacks who. Text-only, audio-only, or both.
  • MM-ArgFallacy2025 — the competition around it. Test set includes the 2024 Trump–Harris debate.
  • MAFALDA — unified fallacy benchmark. Allows multiple correct labels per sentence, because real fallacies overlap.
  • ElecDeb60To16 — ~30,000 debate sentences, hand-labelled with claims, reasons, attacks. Free training data.
  • Multimodal-USElecDeb60To16 — every sentence timestamped to its second in the video. Transcript↔audio alignment, solved.
  • mm-argfallacy (2025) — proved that feeding the sentences before is what makes it work. Your wait-for-context idea, confirmed with numbers.
⚡ The shortcut Squash missed: match the claim to a check that already exists

Squash idled because it waited for fresh fact-checks. Matching a live claim to an existing one is instant and dirt cheap. Do this first. Dig deep only on a miss.

📜 Receipts — 'he voted against it' is a database row, not an AI guess
  • UK Parliament Developer Hub — official endpoints: members, Commons votes, Lords votes, financial interests.
  • TheyWorkForYou API — cleaned Hansard (official record of everything said in Parliament). Any politician’s speeches + voting history. Free for non-profit.
  • EU Parliament Open Data API — MEPs, sessions, votes, documents.
  • World Bank API — no key, no signup. Every economic number, every country.
  • Our World in Data — clean series you can drop straight into the red box.
  • SDMX — Eurostat, ECB, IMF, OECD, UN and World Bank all answer the same query language. Learn once, six databases open.
  • Librarian’s API list — FRED, OECD, IMF, SEC filings. No SEO junk.
🔒 Stop asking the model for JSON — make broken JSON physically impossible

“Respond only in JSON” is a request. The model ignores it eventually, at 2am, during your demo. Lock the output instead.

  • Outlines — describe the shape, get that shape, every time. Works with Ollama.
  • XGrammar — already inside most local-model servers. You may have it.
  • llguidance — fastest, near-zero startup. For tight latency budgets.
  • lm-format-enforcer — locks shape but lets the model breathe, which improves the contents too.
🎭 Check the audio is real before checking the words (voice cloning is free now)
  • awesome-fake-audio-detection — maintained list of every fake-voice detector.
  • media-sec-lab / Audio-Deepfake-Detection — datasets + code, with tables showing which hold up on new fakes.
  • c2pa-rs — reads the cryptographic “birth certificate” cameras and editors now bake into files. Video and audio too.
  • c2patool — one command, JSON out: who made this, what edited it, was AI involved.
  • c2pa-attacks — that birth certificate is just text an attacker can write. If your red box prints it, you built an injection hole. Read before shipping.
🌍 Parliaments outside English — the crews already doing this elsewhere
💡 What this actually gets you — 5 things you could do this week 
claim ──► worth checking? ──► already debunked? ──► YES ──► verdict in 2s
                                     │
                                     └─ NO ──► fetch evidence ──► verify ──► verdict
  • Politician says “unemployment fell 12%.” Your box pulls the actual World Bank series and shows the real number next to his. No opinion. Just the row.
  • He quotes a rival. Archive lookup finds the original line — and the sentence he chopped off the end.
  • Same false claim, third time this month. Matched to an existing fact-check in 2 seconds, no fresh research needed.
  • Voice on a viral “leaked” clip fails the fake-audio check before you even reach the words.
  • He says something ugly, then walks it back 40 seconds later. Your delay catches the retraction, and the red box never fires. That’s the feature.
⚠️ Three honest ones before you build further
  • Wait-for-context was right. You guessed it, a 2025 paper proved it. The delay isn’t a compromise — it’s the feature. Instant verdicts are how you defame someone over a half-finished sentence.
  • Body language is your weakest brick. Deception cues barely survive outside a lab and read differently across cultures. A wrong “he’s lying” over a man’s face is what gets an extension buried instead of shared. Ship the claim spine first.
  • On the repo. Not a lawyer, not pretending. But notice: every project above checks words, not people. No profiles, no face scores, no human ranking. Squash, ClaimBuster, Full Fact — all public, all funded, all still standing. There’s a shape of this that lives in daylight, and it’s the same shape that works better.

The stack exists. It’s just scattered. Pick the pieces, snap them together, done.

A claim with a public record behind it isn’t an accusation. It’s a receipt.