Self-hosted service
SummerSec/ShiroAttack2 avatar
SummerSec/ShiroAttack2

ShiroAttack2 records one licence in the repository and a different one in its package manifest

Comprehensive exploitation tool for Apache Shiro deserialization vulnerabilities (for authorized testing only).

2,644 stars293 forksJavaMIT

At a glance

What is it?
SummerSec/ShiroAttack2 is a Java tool for the Apache Shiro rememberMe deserialization issue, built as a desktop interface and a command line program that share one attack service, distributed as a single jar or a bundle with a key dictionary and a library folder, and shipped to coding agents as a skill file. Its licence is MIT in the repository record and Apache 2.0 in its package manifest, a compiled class file sits in the root, and two of its six commands leave state on the target that the operator was not asked about.
Who is it for?
Read this one as a description of a capable tool and of the decisions its author made about it, not as something to run. Written authorisation is the first thing to settle, and the project's own documentation requires it in writing before any test, names the laws it invokes, and forbids redistribution to unauthorised users.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 164 days ago.
What is it written in?
Mainly Java, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • SummerSec/ShiroAttack22,644 ★ · +12
Star history
Repository2026-10-042026-11-15
SummerSec/ShiroAttack22.6k2.6k

12 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One attack service with two front ends

The engineering story of this project is in how it stopped being a desktop program. The core service is over a thousand lines and, the page says, was not modified when command line mode arrived after version 5.0. Instead of rewriting the logic, the author made the graphical program's own plumbing reusable: a subclass of a text widget intercepts the log output, and a controller factory that the interface already uses is given a fake main controller, so the same service that a window drove is driven by the terminal. Command line mode still initialises the desktop toolkit at startup, using a panel widget, so the runtime is present either way. That is a tidy trick and it is the reason the two modes cannot drift apart, and it is also the reason the program needs a graphics toolkit installed on a machine with no display.

MIT in one record and Apache 2.0 in another

The licence is the first thing to check in a tool like this, because the project's own terms restrict who may run it and who may pass it on. The repository's record says one thing, the package manifest that describes the project to tooling and registries says another, and the two disagree about which licence applies. The tree does contain a licence file, so the terms are written down somewhere, but neither the repository record nor the manifest points a reader at the same answer. For a project that ships a fat jar, a bundle archive and a skill file for coding agents, and that explicitly forbids redistribution to people without authorisation, an ambiguous licence is a real obstacle rather than a technicality: nobody can tell from the metadata whether a security team may vendor it internally.

A compiled class file is committed to the repository root

The root of the repository holds a compiled Java class file, an assembly descriptor, an IntelliJ module file, two directories whose names differ only by a plural letter, and a directory of bundled jars. The class file is the one worth stopping on: compiled output does not belong in version control, it is generated by the build, and once committed it shadows whatever the build produces later, which is how a stale artefact ends up on a classpath. The assembly descriptor and the module file are IDE conveniences that many projects gitignore. Two directories that differ by an s are worse than untidy, because a build that copies from one while a reader edits the other produces a jar that disagrees with the checkout, and the documentation refers to the jars by directory.

The release is a jar beside a key dictionary and a library folder

Two artefact shapes are published. One is a single executable jar, and the other is a compressed bundle that contains a data directory and a library directory alongside it. The layout matters, because the data directory holds a key dictionary, one key per line, and the library directory holds the gadget library versions the payload needs. So this is not a self contained binary: it is a program plus a dictionary of candidate keys plus a set of library jars it loads at run time. The release page says the automation workflow builds these when a version tag is pushed, and that an optional release note can be added per tag. Anyone mirroring the project has to mirror the dictionary too, or the program will start and find nothing to work with.

The build installs two third-party jars by hand first

The build section is three commands and the first two are not a build. Each installs a jar from the bundled directory into the local Maven repository under a synthetic group and artifact name, so that the build can resolve them like any other dependency. Only then does the project get packaged, skipping the tests, into a fat jar built for an older Java target:

bash
mvn clean package -DskipTests

The comment above that command in the build section names the resulting artefact file, version and all. The two installed libraries are the third-party payload and memory shell generators, which the feature list names as optional integrations that fall back to a built-in path when they fail. That fallback is the interesting part: a run can silently do something different from what the feature list's wording suggests, and nothing in the output format tells you which path was taken.

Two of the six commands change the target, not just read it

This is the section that decides whether the tool belongs in your engagement. Six commands are documented: detect the target framework, work on the encryption key, execute a command, inject a memory shell, replace the key, and open the interface. Three of those are ordinary for an exploitation tool in an authorised test. The other two are not: a memory shell writes into the running server's own filters, servlets, interceptors, handlers or valves, and the key replacement function changes the server's key so the old one stops working, which is a modification an owner may not have authorised even during a test window. Alongside those sit a proxy option with authentication, five echo styles including one that connects back to you, and a document about getting past web application firewalls. There is no per target authorisation check, no dry run, no scope list and no abort switch. The written permission should therefore describe those five behaviours by name, not just say testing is authorised.

The documentation is packaged for coding agents as well as people

The repository ships its instructions in three formats at once. There is a full usage document, a frequently asked questions document, a deep dive per version, and separate documents for the memory shell, for the firewall bypass and for the no gadget case. Then there is a skill file described as a description for a coding agent to load, structured as command arguments and troubleshooting rules, and a set of agent instruction files, including two with near identical names at the root. There are also per tool plugin directories for three assistants and a plugin manifest beside a package manifest. So the tool is designed to be driven by another program as much as by a person, which raises the bar on the documentation: whatever an agent reads is what it will do, and the same warnings that appear at the bottom of the human documentation are the ones an agent is least likely to encounter.

Editorial conclusion

Read this one as a description of a capable tool and of the decisions its author made about it, not as something to run. Written authorisation is the first thing to settle, and the project's own documentation requires it in writing before any test, names the laws it invokes, and forbids redistribution to unauthorised users. If that is in place, two more things need deciding before use. The licence is recorded two different ways, and for a tool its own terms restrict distribution, the licence is not a detail to sort out later. And the capability list includes functions that modify the target persistently rather than just reading it, so a scope agreement that permits testing may not permit what these commands actually do. Anyone without a written scope should stop at this paragraph rather than at the documentation.

Frequently asked questions

What is ShiroAttack2?

A Java tool for the Apache Shiro rememberMe deserialization issue tracked as CVE-2016-4437, offered as a desktop application and a command line program that share one attack service, with six commands covering detection, key work, command execution, memory shell injection, key replacement and the interface itself.

Why is a 2016 Shiro issue still usable?

The page gives three reasons: older framework versions shipped with a hardcoded default encryption key that tutorials and scaffolding copied for years, the key gets embedded in configuration files, images and repositories so changing it means changing every node at once, and the tooling cost is low enough that a point and click interface is enough.

How is ShiroAttack2 built?

With Maven. Two third-party jars from the bundled directory are installed into the local repository by hand first, then the project is packaged with tests skipped into a fat jar for an older Java target, and releases are built by an automation workflow when a version tag is pushed.

What does ShiroAttack2 need at runtime?

Either a single executable jar or a bundle archive. The bundle contains a data directory holding a key dictionary with one key per line and a library directory holding the gadget library versions the payload needs, so the dictionary has to travel with the program.

Is ShiroAttack2 authorised for use?

Its documentation restricts use to authorised testing and research, requires written authorisation before any test, cites the national cybersecurity, data security and personal information laws plus two criminal code articles, states the maintainers accept no liability, and forbids redistributing it to unauthorised users.

Does ShiroAttack2 support proxies and output formats?

Yes. HTTP and HTTPS proxies are supported including authentication, there is a mode switch for the two encryption modes used by different framework version ranges, and a JSON output mode that splits structured log lines from raw command output so a script can parse one and tail the other.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. Releases
  5. SummerSec/ShiroAttack2 on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/summersec-shiroattack2.svg)](https://hysenlabs.com/projects/summersec-shiroattack2)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/summersec-shiroattack2.svg)](https://hysenlabs.com/projects/summersec-shiroattack2)

Was this useful?