Aegis

Don't just hide your code. Make it fight back. AI-powered software protection that turns reverse-engineering tools against the very software they're trying to crack.

Comment

Inspiration — Your software is becoming easier to clone.

Reverse engineering is changing fast.

With modern decompilers and AI-powered tools, understanding and reconstructing software is becoming increasingly accessible. An application that took years to develop can potentially have its proprietary algorithms, business logic, and functionality studied and recreated.

And the uncomfortable truth? Most software protection is passive.

Developers obfuscate their code, ship their application, and hope those defenses hold up. But how do they know whether their protection actually works? What happens when an attacker finds a way through?

We asked ourselves a different question:

What if your software could fight back?

What if it could protect itself, attempt to reverse engineer its own defenses, discover weaknesses, and eventually improve automatically?

That's why we built AEGIS.

What it does — Meet AEGIS

AEGIS is an AI-powered software protection platform that brings together compiler-level defenses, deception, reverse-engineering analysis, and cryptographic verification.

Instead of relying on one protection technique, we built five interconnected systems.

Shield — Transform the code.

Our LLVM-based protection engine modifies selected program logic while preserving its intended behavior. It operates at the compiler level, beyond simply renaming variables or hiding source code.

Mirage — Make attackers question what they're seeing.

Mirage inserts plausible decoy functions into protected software, adding alternative targets for static analysis without interfering with legitimate execution.

Adversarial Lab — Attack our own defenses.

Using Ghidra and NVIDIA Nemotron, AEGIS analyzes compiled executables and attempts to reconstruct their functionality from reverse-engineered evidence.

The ambition is to move beyond asking "Did we obfuscate the code?" and start asking "What can an attacker actually recover?"

Signature & Sentinel — Verify and control.

Cryptographic signatures verify artifact integrity, while Sentinel enforces supported access and distribution policies.

AEGIS Dashboard — Everything in one place.

A working interface connects protection jobs, artifacts, signatures, policies, downloadable results, and AI reconstruction evidence.

All five systems have working implementations in our hackathon prototype. Together, they form the foundation of something bigger: protection that can eventually test and improve itself.

How we built it

We built AEGIS using C++ and LLVM 22 for compiler-level protection, Python for orchestration and adversarial research, and React/TypeScript for the dashboard.

We integrated Ghidra for actual executable analysis and NVIDIA Nemotron-3.5-Lightning through Nebius Token Factory for AI-assisted reconstruction.

We also implemented real API/CLI workflows, Ed25519 signing, Sentinel policies, artifact hashing, and automated verification.

Rather than limiting ourselves to artificial examples, we tested our own ImageLab application alongside supported components of real C++ and Rust projects, including reVC and PhotoCraft.

Challenges — Making protection work in the real world

1. Mirage: fake code isn't as simple as it sounds.

Our initial approach was to mix fake logic into real code. But that introduced problems: potential bugs, added compilation complexity, and decoys that an AI-assisted analyst could recognize as irrelevant.

We had to rethink the design.

Instead, we built Mirage around separate deterministic LLVM modules. Decoy functions are generated independently, linked using llvm-link, and preserved with compiler retention attributes so optimization doesn't simply remove them.

We also kept them free of runtime hooks, I/O, and mutable global state, reducing the risk of interfering with the real application.

The result: three decoy functions survived optimization and linking in our tested native executables, while the application's outputs remained unchanged.

We also discovered that retained decoys can still be identified as unreachable. Making them genuinely deceptive against advanced analysis remains an important research challenge.

2. Shield: the compiler was undoing our work.

We discovered that transforming LLVM code doesn't guarantee the transformation survives compilation.

In some experiments, compiler optimization simplified Shield's changes until the final executable became identical to the original.

That taught us to verify more than transformed source or intermediate representation. We needed to inspect actual compiled artifacts, verify transformation survival, and independently test behavior.

3. Nemotron: getting real AI reconstruction working.

Our first live Nemotron experiments repeatedly consumed their output limits without returning valid reconstruction candidates.

We investigated the model configuration and implemented controlled thinking-disabled inference.

That produced a genuine, structured reconstruction candidate from real Ghidra evidence.

But generating code isn't the same as successfully reconstructing a program. We kept the candidate behaviorally unscored rather than executing untrusted code without validated isolation.

4. Making the entire platform trustworthy.

Compiler passes, decompilers, AI models, and signing systems all produce different artifacts. Connecting the wrong evidence to the wrong build could completely invalidate an experiment.

We implemented strict SHA-256 artifact binding, reproducible records, and verification checks. Our adaptive prototype even rejected genuine ImageLab evidence when it didn't match the target being evaluated.

For a system intended to measure protection, knowing when not to trust a result is just as important as producing one.

Accomplishments — What we actually built

We delivered AEGIS 0.1.0, a working, open-source software-protection research platform.

During the hackathon, we successfully implemented and integrated:

  • Real LLVM Shield transformations and Mirage defensive decoys.
  • Ghidra-based executable analysis and genuine NVIDIA Nemotron reconstruction generation.
  • Ed25519 artifact signing, integrity verification, and Sentinel policy enforcement.
  • A functioning dashboard, API, and CLI.
  • Protection experiments on actual native C++ and Rust components.
  • Reproducible evidence, automated tests, and a publicly available MIT-licensed release.

Our final release passed 806 companion tests, 2,117 strict Adversarial Lab tests, and 22 end-to-end browser tests, alongside native verification and successful GitHub CI.

We demonstrated real protected artifacts, verified signatures, policy decisions, downloads, and a genuine NVIDIA-generated reconstruction candidate.

The full autonomous optimizer and independently measured resistance improvements are not finished yet. But the underlying protection, adversarial analysis, and verification systems are real, connected, and operational within their supported scope.

We didn't build a mockup of what AEGIS could become. We built the foundation it needs to become real.

What we learned

The biggest lesson was that complicated code isn't necessarily protected code.

Changing a binary, inserting decoys, or generating thousands of passing tests doesn't prove that reverse engineering became harder.

Real protection needs functional correctness, genuine attacks, independent measurements, and reproducible evidence.

We also realized that AI's most valuable role may not be generating code, but helping a defensive system understand what attackers can discover and decide how to respond.

What's next — The real vision

AEGIS 0.1.0 is the beginning. Our goal is to turn it into a fully autonomous, adaptive software-protection platform.

Imagine connecting your repository or application and telling AEGIS:

"Protect my proprietary algorithms. Don't break anything. Keep performance overhead below 10%. Test what an AI-assisted attacker can recover and give me the strongest verified release."

The finished system will work toward that goal through a continuous cycle:

Analyze → Attack → Protect → Build → Verify → Attack Again → Measure → Improve → Repeat.

First, we'll complete the missing connection between our existing systems: securely isolated reconstruction scoring, matched baseline-versus-protected attacks, genuine REA integration, and an optimizer that selects defenses based on measured results.

Then we'll expand the intelligence behind AEGIS. NVIDIA models such as Nemotron will help analyze software, identify sensitive logic, plan defenses, simulate attacks, interpret results, and guide protection improvements.

Shield will grow into a broader protection engine covering control-flow and data-flow transformations, string and constant protection, code diversification, selective virtualization, and tamper resistance. Mirage will evolve toward decoys whose effectiveness is actually measured against attackers.

Our longer-term ambition extends beyond native C/C++ software: specialized backends for Rust, Go, JavaScript, WebAssembly, desktop applications, websites, mobile apps, games, embedded systems, and authorized console environments.

We also envision stronger ownership evidence, automated release signing, CI/CD integration, private deployments, and enterprise-grade security.

Ultimately, we want a developer to give AEGIS their software and receive a functioning, protected, cryptographically verifiable application—alongside evidence explaining what protection was applied, what attacks were attempted, and how well the defenses performed.

We're not claiming software can become impossible to reverse engineer.

We're building toward a future where software protection doesn't stop when an application ships. It keeps testing, learning, and improving.

AEGIS — Don't just hide your code. Make it fight back.

A note from our team

AEGIS was built in just 48 hours.

In that time, we went from an ambitious idea to a working, tested, open-source prototype integrating compiler-level protection, reverse-engineering analysis, NVIDIA AI inference, and a functioning application.

Unfortunately, we ran out of time before the submission deadline and couldn't record the proper demonstration we had planned. Since Devpost required a YouTube video URL to complete the submission, we attached a temporary video rather than leave the project unsubmitted. Please note that the attached video is not an actual demonstration of AEGIS or a reflection of its capabilities.

We prioritized completing the software, validating our work, and publishing the project. Our GitHub repository contains the source code, documentation, tests, and instructions for exploring the real implementation.

What we submitted is only the beginning of what we intend to build.

Built With

Share this project:

Updates

Submission history