RedFlag — Phishing & Fraud Alert Platform

A multilingual, multimodal, explainable fraud-alert platform for the South Chennai threat landscape.

NextGen AI Hacks 2026 · Track: Digital Trust, Forensics & Anti-Fraud Systems

Paste it, screenshot it, or scan it. RedFlag tells you what is suspicious, why it is suspicious, whether it resembles a known campaign, and what to do next.

RedFlag accepts a suspicious SMS/WhatsApp message, a URL, a screenshot or a QR-derived link. It normalizes the evidence, performs OCR where needed, understands Tamil / English / Tanglish scam intent, analyzes URLs and extracted entities, computes an evidence-backed 0–100 risk score, explains the red flags, and enables community reporting.

The loop is Detect → Explain → Correlate → Report → Learn → Protect. Repeated phones, domains, UPI IDs, handles and message templates become campaign relationships, turning isolated warnings into reusable regional threat intelligence.

Prerequisites: Python 3.11+, Node 18+, npm.

git clone https://github.com/nandv2007/RedFlag--Phishing-and-Fraud-Alert-Platform.git
cd RedFlag--Phishing-and-Fraud-Alert-Platform

# Optional but recommended — enables screenshot OCR (incl. Tamil) and QR decoding.
# Without these RedFlag still runs; the checks simply report as "degraded".
sudo apt-get install -y tesseract-ocr tesseract-ocr-tam libzbar0

./run.sh                 # installs deps, builds the dataset, trains the model,
                         # seeds the demo, measures metrics, then serves everything

Then open http://localhost:5173.

pip install -r requirements.txt
cd backend
python data/build_dataset.py            # synthetic dataset, disjoint train/test
python -m app.intel.classifier --train  # optional TF-IDF classifier
python seed_demo.py                     # repeatable demo graph
python evaluate.py                      # writes data/metrics.json
cp data/metrics.json ../frontend/public/metrics.json
python -m uvicorn app.main:app --reload --port 8000

# in a second terminal
cd frontend && npm install && npm run dev

Copy .env.example to backend/.env to change limits, the database URL or CORS. No secrets are committed to this repository.

A result is reachable in ≤ 3 clicks from landing: pick an input card → paste/upload → Analyze.

Everything the UI does is available over HTTP. Interactive docs at /api/v1/docs.

POST /api/analyze/text      POST /api/analyze/url
POST /api/analyze/image     POST /api/analyze/qr
GET  /api/analysis/{id}     GET  /api/analysis/{id}/evidence
POST /api/reports           GET  /api/reports/queue
POST /api/reports/{id}/approve | /reject | /merge
GET  /api/feed              GET  /api/entities        GET /api/entities/{type}/{value}
GET  /api/campaigns         GET  /api/campaigns/{id}  POST /api/campaigns/{id}/status
GET  /api/pulse             GET  /api/health          GET /api/meta

# preserved baseline
POST /api/v1/scan/url       POST /api/v1/scan/sms     GET /api/v1/threats/known
GET  /health

A browser extension, Telegram/WhatsApp bot or mobile client can reuse these directly — the analysis endpoints are stateless JSON and need no session.

Every input type — text, URL, image, QR — converges on one schema. There is no separate business logic per mode.

{
  "analysis_id": "an_7d4ff0…", "input_type": "text", "language": "ta-en",
  "verdict": "CRITICAL", "risk_score": 98, "confidence": 0.95,
  "scam_category": "kyc_account_freeze",
  "summary": "Do not act on this message. …",
  "red_flags": [ { "title": "…", "detail": "…", "evidence_span": "…", "kind": "observed" } ],
  "risk_factors": [ { "name": "…", "family": "message_intent", "weight": 8.0,
                      "observed_value": "…", "evidence_span": "…", "source": "rule:intent" } ],
  "entities": [ { "type": "upi", "raw_value": "…", "display_value": "…",
                  "canonical_hash": "…", "evidence_span": "…" } ],
  "campaign_links": [ { "campaign_id": "camp_…", "reasons": [ { "relation": "same_indicator" } ] } ],
  "recommended_actions": [ { "priority": "critical", "action": "…", "why": "…" } ],
  "model_version": "redflag-intel-1.0.0", "degraded_checks": [], "created_at": "…"
}

Risk = min(100, Σ capped family contributions − legitimate-message credit)

Bands: 0–24 Low · 25–49 Caution · 50–74 High · 75–100 Critical. These are product thresholds, not legal truth.

Every contribution is stored as a risk_factor with its weight, observed value, evidence span and source — visible in the UI under “Show how we know” and in the database table risk_factors. Judges can inspect exactly why a number moved.

Language is a routing signal, never a verdict. A Tamil message is not suspicious because it is Tamil — there is a regression test (test_language_alone_is_not_a_verdict) that fails the build if that ever changes.

• Text — SMS, chat, email snippets.
• URL — direct, or extracted from the message.
• Image — Tesseract OCR with eng+tam, per-word confidence, bounding boxes, and an editable text box so the user corrects OCR before analysis. The UI always shows “OCR may be wrong”, and nothing is ever invented to fill a gap.
• QR — decoded locally with pyzbar (OpenCV fallback). The destination is displayed and never opened automatically, then sent through URL analysis.

If Tesseract or zbar is absent the request still succeeds: the adapter returns available: false with a reason, the API lists it under degraded_checks, and the UI shows an amber banner inviting manual text entry.

For the MVP, correlation is deterministic and explainable rather than clever:

• Hard indicators — domain, phone, UPI, handle, email, IFSC — merge observations.
• Message fingerprint — digits and URLs stripped, remaining tokens sorted and hashed, so the same template with a rotated link or amount still collides.

Relations stored: reported_in, mentions, same_indicator, shares_template, similar_to.

The campaign view shows the graph, the sighting timeline, the indicators shared by 2+ reports, and an infrastructure-rotation note. Shared infrastructure is presented as evidence of overlap, not proof of identical actors.

Only moderated reports enter the graph. That is the answer to report poisoning.

Run it yourself:

cd backend && python evaluate.py

It evaluates on a held-out validation split whose templates are disjoint from training (the build script asserts this), with community reputation and campaign boosts disabled so the number cannot be inflated by the seed data.

Latest run on this machine (backend/data/metrics.json, 124 held-out samples):

Per-language accuracy: en 1.00 · ta-en 0.96 · ta 0.67 (12 samples).

These describe this synthetic dataset only. They are not a claim about field performance, and the UI repeats that caveat next to the numbers. Anything we did not measure is labelled “not measured” rather than guessed.

No live external reputation feed is connected in this build. /api/health says so explicitly (external_threat_feeds: local_only) rather than implying a capability we do not have. If a feed fails or is absent, local analysis still returns a useful result and the UI lists which checks were unavailable.

frontend/  React 19 + TypeScript + Vite + Tailwind v4
  src/intel/        RedFlag Intelligence console (dark security theme)
    IntelConsole    shell, nav, health pill
    AnalyzeHub      four first-class inputs + OCR correction flow
    ResultView      score, red flags, breakdown, entities, actions, audit trail
    CampaignView    deterministic SVG graph, timeline, shared indicators
    Community       report form, public feed, moderation queue, threat pulse
  src/components/   preserved classic scanner (light theme)

backend/   FastAPI
  app/api/intel_routes.py   contract endpoints
  app/api/endpoints.py      preserved /api/v1 baseline
  app/core/security.py      rate limits, body ceiling, safe errors, headers
  app/intel/
    language.py    Tamil/English/Tanglish detection + normalization
    entities.py    phone/url/domain/email/UPI/handle/brand/amount/txn extraction
    intent.py      intent families + scam classes with evidence spans
    classifier.py  optional TF-IDF + logistic regression
    adapters.py    OCR and QR, both degrading gracefully
    analyzer.py    evidence fusion → canonical AnalysisResult
    graph.py       fingerprints, correlation, campaign graph, threat pulse
    reports.py     reporting, duplicate detection, moderation, evidence bundle
    db.py          SQLAlchemy models (SQLite demo / PostgreSQL deployment)
  app/services/    preserved URL engine: entropy, homograph, brand, lexical,
                   network, normalizer, expander, risk scorer, SMS analyzer
  data/            synthetic dataset generator, validation split, metrics
  seed_demo.py     repeatable demo
  evaluate.py      measured metrics

Database tables: users, analyses, evidence, entities, analysis_entities, risk_factors, reports, relationships, campaigns.

Re-run ./run.sh seed before each rehearsal to get an identical starting dashboard.

Also worth showing: the Legitimate bank SMS sample scores 12/LOW — RedFlag is not a machine that shouts "scam" at everything.

./run.sh test      # or: python -m pytest -q

118 tests. backend/tests/test_intel_pipeline.py and test_intel_api.py are written as acceptance tests against the implementation contract — each one names the P0 row it protects: baseline preservation, unified schema, score+verdict+evidence, all three languages, URL evidence, OCR correction, entity extraction, community reporting, campaign clustering, duplicate merge, polished result contract, seeded demo, and security basics.

• Trained and evaluated on synthetic data. Real-world precision and recall will differ.
• Pure-Tamil-script recall is the weakest arm (0.67 on 12 samples) and is the first thing more data should fix.
• No live threat feed, no WHOIS/domain-age lookup, no sandbox detonation of links.
• The campaign graph is deterministic overlap, not graph ML.
• RedFlag is risk assessment and decision support. It does not prove fraud, is not a legal determination, and never infers who owns an indicator.
• Never take an irreversible financial action based on the score alone.

• Phase 2 — Public beta: browser extension, mobile client, threat-feed ingestion, a stronger Indic multilingual model.
• Phase 3 — Ecosystem: messaging integrations, institutional dashboards, partner APIs.
• Phase 4 — Advanced intelligence: graph ML, temporal anomaly detection, cross-platform correlation, privacy-preserving analytics.

Report cyber-fraud in India: call 1930 or file at cybercrime.gov.in.