Tribunal is an agentic Android app pentest pipeline that automatically decompiles, dynamically verifies, and tests APIs, then subjects findings to an adversarial courtroom trial before reporting.

Stars

8

7-day growth

No data

Forks

5

Open issues

0

License

No data

Last updated

2026-07-30

AI repository intelligence
FR-AI / ANALYSIS

Why it is worth attention

It introduces a courtroom-style adjudication process where prosecution/defense/judge verify each finding, reducing false positives, and it is fully agent-driven with structured skills that pass JSON between stages.

Who it is for

  • Android penetration testers
  • Security researchers analyzing mobile app vulnerabilities
  • App developers wanting automated security review integration
  • Security engineering teams building CI/CD pentest pipelines

Use cases

  • Automated end-to-end security assessment of Android applications
  • Validating API vulnerabilities (IDOR, BOLA, injection) with dynamic testing
  • Adversarial cross-examination of findings to avoid false positives
  • Integrating into authorized testing workflows with a clear scope gate

Strengths

  • Adversarial courtroom verification ensures only corroborated findings are reported
  • Agentic skills orchestrate static, dynamic, and API testing without manual gating
  • Scope gate via apk/ directory enforces authorized-use boundary and fails closed
  • Vendored tooling (apktool, jadx) reduces setup friction for decompilation

Considerations

  • Requires manual setup of Android emulator, Burp Suite, Frida, and adb on the user's machine
  • Pipeline only supports Android APKs and is not designed for other mobile platforms
  • Relies on external third-party tools (jadx, apktool, objection) that may have their own limitations

README quick start

Tribunal

An authorized-testing Android app pentest pipeline built as a small set of agentic skills. Drop an APK in apk/; every finding that survives static review, dynamic verification, and API testing goes through an adversarial prosecution/defense/judge trial before it's written up — no finding reaches report/ without standing up to cross-examination. Skills pass structured JSON through targets// and keep raw decompiled output (apktool/, jadx/) on disk for manual pivoting.

 APK ─▶ 1. decompile-threat-review ─▶ 2. dynamic-verify ─▶ 3. api-vuln-test ─▶ 4. courtroom-verdict
         (static, autonomous)          (your emulator+Burp)  (server-side API)   (prosecution/defense/judge)
         threat_model.json             evidence/, status      api_findings.json   report//-.md
         report.json (candidates)      frida/bypass.js

Authorized use only. apk/ is the scope boundary — an APK physically placed there is your own assertion that you own it or are authorized to test it. No package registry to maintain; scripts fail closed on the resolved path (see CLAUDE.md). Methodology + standard tooling only — writing a custom Frida pinning bypass for your own emulated app is expected; building tools that attack apps outside the apk/-is-scope model is not.

Requirements

  • Python 3.10+ (bundled scripts; standard library only). Java (any recent JRE) to run apktool/jadx — vendored under tools/ (Windows + Linux launchers), no separate install needed; scripts prefer PATH if you already have your own.
  • On PATH: adb, frida + frida-server (pip install frida-tools objection); Burp Suite and the Android Studio emulator for the dynamic stages. Scripts degrade gracefully if a tool is missing.

Run it like this

Clone the repo, drop an APK in apk/, and trigger the pipeline — that's the whole setup. Under the hood:

# 1. Decompile (scope-checks the path against apk/ automatically) + build the threat model
python skills/decompile-threat-review/scripts/inventory.py --apk apk/app.apk
#    -> targets//{apktool,jadx}/, inventory.json, evidence/, frida/
#    Then a main agent fans out subagents (default, not opt-in) -- one builds the structural
#    threat model, four review disjoint rubric slices in parallel, skeptics try to refute each
#    candidate -- and writes targets//t

Related repositories

Similar projects matched by category, topics, and programming language.

lopopolo
Featured
lopopolo GitHub avatar

harness-engineering

Harness Engineering is a methodology for improving coding agent outputs by carefully crafting the environment around them—providing curated context, tools, and executable constraints that encode an organization’s nonfunctional requirements and cumulative lessons.

AI & Machine LearningAI Agents
2,390
MoonshotAI
Featured
MoonshotAI GitHub avatar

Kimi-K3

Kimi K3 is an open-weight, 2.8T-parameter native multimodal agentic model with a 1M-token context window, designed for frontier coding, knowledge work, and reasoning tasks.

AI & Machine LearningAI Agents
3,348
mshumer
Featured
mshumer GitHub avatar

Claude-of-Duty

A browser-based first-person shooter built entirely with procedural generation and orchestrated AI agents, featuring 55k lines of Three.js/WebGL2 code and no art assets.

AI & Machine LearningAI Agents
1,234