cd /news/ai-safety/show-hn-blue-harness-audit-and-harde… · home › topics › ai-safety › article
[ARTICLE · art-170419] src=github.com ↗ pub= topic=ai-safety verified=true sentiment=↑ positive

Show HN: Blue-harness – audit and harden binaries against AI-assisted reversing

A developer released blue-harness, an open-source build-time hardening and audit toolkit for native binaries and mobile apps, which in a single N=1 test run by a 4-bit-quantised 7B model on an RTX 3070 laptop let an AI agent crack an unprotected build in 1.6 seconds and 1,256 tokens but fail against the hardened build after 16,785 tokens and 195 seconds — roughly 13× the tokens and 120× the wall-clock. The toolkit audits a build's exposure, applies nine countermeasures such as anti-debug, string encryption and a dev-to-release identity transform, and verifies each defense actually fires; author seifheakal notes the honeytoken layer never fired because the agent was stopped earlier, and asks users with larger models to submit scored results as pull requests.

read8 min views1 publishedNov 16, 2026
Show HN: Blue-harness – audit and harden binaries against AI-assisted reversing
Image: Michielbdejong (auto-discovered)

Make your own app expensive to reverse — measure it, harden it, prove it.

Anyone can now reverse-engineer a shipped app by typing one sentence to an AI agent; blue-harness makes that expensive, measures how expensive, and proves each defense actually fires.

A build-time anti-reverse-engineering hardening & audit harness for native binaries and mobile apps you own.

<sub>Recorded with docs/assets/demo.tape. Real output, nothing staged.</sub>

git clone https://github.com/seifheakal/blue-harness && cd blue-harness
make demo      # audit a sample build, show its hardening plan, then PROVE every defense fires
make verify    # run every check and print one posture summary

Point it at your own binary:

make report BIN=path/to/your/binary   # exposure audit + the ordered hardening plan
make harden BIN=path/to/your/binary   # apply every post-build hardening (honest about the rest)

No external dependencies: a C toolchain, make, and Python 3.

Caution

Our before/after below is one run (N=1) by a small, 4-bit-quantised 7B model on a laptop (RTX 3070, 8 GB VRAM / 16 GB RAM) — a floor, not a ceiling. If you have the hardware, point a larger local or a frontier model at the same two builds and send the scored result back as a PR. A stronger attacker is the only way to test the layers our small run never reached. It is now one command — make slice-k-run MODEL=<your-model> builds the sealed pair, drives the agent, and prints the honest before/after (and we fixed the tool-call friction that blocked commodity local models). Five-minute guide: docs/HOW-WE-TESTED.md.

Reverse engineering used to take real skill. Now anyone can point an AI agent at a binary, type one sentence, and get back readable code or a working patch — and commodity cracking of shipped software exploded with it.

blue-harness is a defensive toolkit aimed at that threat. It runs against your own build and does three things, audit-first:

  • Audit — scan a build and score how exposed it is (symbols, strings, entropy, hardening flags, which self-defense guards are present).
  • Harden — apply tested countermeasures to raise the attacker's cost.
  • Prove — verify each countermeasure actuallyfires , so your protection isn't theater.
build cracked (hash-verified) tokens wall steps
unprotected YES 1,256 1.6 s 3
hardened no 16,785 195 s 13

The same agent cracked the unprotected build in under two seconds; against the hardened build it burned 13× the tokens and ~120× the wall-clock and still failed. String encryption, anti-debug, and analysis-surface exhaustion were all seen firing. Honestly: the honeytoken layer never fired — the agent was stopped earlier, so that layer went untested (exactly what a bigger model would exercise). Method and caveats: docs/HOW-WE-TESTED.md · full write-up.

Nine countermeasures, each proven to fire by a test and each carrying an honest strength tier and a named bypass — nothing here claims to be unbreakable.

Countermeasure Blunts Tier Named bypass
Anti-debug / anti-ptrace live debugging & tracing (GDB, Frida attach) Meaningful Frida hooks the check; spawn-d bypass loads first
String encryption (decode-on-demand) reading secrets straight from the bytes Speed-bump→Meaningful embedded key → recover at rest; lift from memory
Dev→release identity transform (strip / rename / decoy) names & symbols an agent reasons from Speed-bump→Meaningful behavioural cross-check ignores names
Anti-Frida detector Frida injection (maps / threads / port) Meaningful stealth mode, renamed gadget, non-default port
Code-integrity + server attestation patching a hot function Meaningful→ Strong (server-tied) sustained live hook; client key is extractable
Core-dump suppression crash-core memory reads Speed-bump re-enable cores on their host; read live memory
Analysis-surface exhaustion the "ingest everything" agent's budget Trivial→Speed-bump filter to real sections + referenced symbols
Honeytokens / canaries poisons string-mined "findings" + attributes a leak Speed-bump / Meaningful (detection) xref-validate drops decoys; rename the tell-tale section
Mach-O local-symbol strip internal names in a macOS/iOS binary Speed-bump→Meaningful exported names remain; runtime-identical proven on macOS only
Mach-O decoy non-mapped segment ( vmsize=0 LC + trailer) the "ingest everything" agent on a Mach-O Trivial→Speed-bump a -faithful tool drops vmsize==0 LCs + the trailer
Mach-O honeytokens / canaries poisons string-mined "findings" + attributes a leak Speed-bump / Meaningful (detection) xref-validate drops decoys; rename the tell-tale marker

A Claude skill reads the posture and tells you the next highest-value hardening — with its tier and bypass, every time.

Working today

  • Read-only exposure audit + score for all three native formats — Linux ELF, Windows PE, macOS/iOS Mach-O — auto-detected by magic byte.
  • The countermeasures above on Linux ELF (build-time + post-build), a WindowsPE harden path (COFF/debug strip + decoy non-mapped overlay + honeytokens), and amacOS/iOS Mach-O harden path (local-symbol strip + decoy non-mapped segment + honeytokens). All three formats auto-detected, all three with a post-build harden path.
  • One-command harden , the driving Claude skill, and aCI gate that re-proves every defense fires on each push (362 checks green).
  • An empirical harness (digest-sealed CrackMe + honest scorer), one measured before/after run , and aone-command re-run (make slice-k-run ) with a robust tool-call shim so a commodity local model can actually drive it.

Not done yet

  • Build-time hardening across PE & Mach-O — both post-build paths ship (PE: COFF/ debug strip + decoy overlay + honeytokens; Mach-O: local-symbol strip + decoy non-mapped segment + honeytokens); relink flags and string-encryptioncodegen still need a rebuild, and runtime checks need a Windows / Mac host to verify.
  • Mobile app reach — Android native libraries via JNI, iOS app internals.
  • More measurement — the before/after is a single run from a small local model (the red box at the top).

Next, in order

  1. More measurement against bigger / reliably tool-calling attackers — the community ask at the top.
  2. String-encryption codegen for PE / Mach-O (it ships for ELF today).
  3. Runtime verification on a Windows / Mac host — lift the post-build harden proofs from structural to runtime-identical.
  4. Mobile (Android / iOS) reach.

Deliberately out of scope: a web/bundle track (Electron / JS / Wasm / .NET). It would only be added later as a separate, clearly-labelled track — never silently, never at the cost of the "prove it" guarantee.

blue-harness isn't the only tool defending against AI-assisted RE — a good sign the threat is real. The difference is depth on native binaries and proof instead of assertion. (Peer descriptions below are from their own READMEs; we ran none of them.)

blue-harness BLA (~2.3k★) antirea (~36★) AREA (~3★)
Focus native binaries + mobile (ELF / PE / Mach-O) breadth: JS / Electron / Wasm / .NET bundles agent instruction-file barriers obfuscation toolbox
Native-binary defenses proven to fire by tests README: Ghidra / Frida / LLDB "not run" — "designed-for", no measured results
Evidence of protection mechanism tests + a measured before/after internal estimates + a drift-check self-limited ("no guarantee") "deterrence, not proof"
Honesty tier + named bypass on every defense status labels; estimate multipliers states its own limits "a determined human gets through"

blue-harness has already absorbed the peers' best native-applicable ideas (surface exhaustion, honeytoken poisoning) as its own, mechanism-proven countermeasures. See the competitive scan.

  • ❌ Not a magic "uncrackable" wrapper. Anti-RE raises cost; a determined, skilled attacker on hardware they control still wins. The harness says so.

  • ❌ Not a secrets vault. If a secret truly can't afford to leak, the first honest recommendation is tomove it server-side — the onlyStrong tier.

  • ❌ Not an offensive tool. Blue team only — it audits and hardens software the operator owns or is authorized to protect. Seedocs/threat-model.md .

  • harness/audit/ — the scored exposure scanners (read-only)

  • harness/harden/ — the countermeasures (+ tiers & bypasses)

  • harness/verify/ — the tests that prove each one fires

  • skill/ — the Claude skill that drives it all

  • docs/HOW-WE-TESTED.md — the two testing layers + how to re-run the measurement (bigger models welcome)

  • docs/ — threat model and the RE-technique catalog

  • CLAUDE.md — project constitution, scope & workflow

Active. All three native formats audited with magic-byte dispatch and each with a post-build harden path; mechanism-proven countermeasures across ELF/PE/Mach-O; a one-command harden; a CI gate with 362/362 checks green (make verify on every push and pull request — the badge above is that gate); and a digest-sealed CrackMe with an honest empirical scorer, now driven by a one-command re-run (make slice-k-run). Roadmap in docs/STATE.md.

blue-harness is open source under the GNU AGPL-3.0 and is free for everyone, including businesses, as long as you comply with the AGPL. To use it in a closed-source product or a proprietary service without AGPL's copyleft obligations, a paid commercial license is available; see COMMERCIAL-LICENSE.md. Evaluation and testing are free for everyone.

── more in #ai-safety 4 stories · sorted by recency
── more on @blue-harness 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/show-hn-blue-harness…] indexed:0 read:8min 2026-11-16 · —