Preface¶

DeepSeek Harness (dsh) treats skills as first-class citizens: the SKILL.md documents the methodology, and the model reads them on demand during loops, rather than stuffing entire manuals into the system prompt. This mechanism is critical for tasks like reverse engineering, authorized penetration testing, and CTFs. For APK, ELF, frontend encryption, and CTF challenges, different toolchains and steps are required. Asking the model to guess commands on the fly often leads it astray.

There is already a large skill pack in the community: zhaoxuya520/reverse-skill. As of 2026-08-17, it has approximately 26,000 stars on GitHub. It is a skill routing package for authorized reverse engineering, penetration testing, and security research, targeting clients like Claude Code, Cursor, and Cline. The problem is that it is not a dsh plugin. To use it in DeepSeek Harness, you either have to manually mount the directory or use an incomplete port.

dsh-reverse-skill does exactly this: it packages all 85 upstream SKILL.md files as a Cordis plugin for distribution and loading alongside the plugin. This article is collated after cross-checking against the community directory page, the plugin repository’s README, package.json, source code, and the upstream reverse-skill repository.

The community plugin directory (deepseek-harness-plugin.com) is an independent site and has no official affiliation with DeepSeek / HyperGAN. Do not treat it as an official app store.

What is this¶

dsh-reverse-skill is a skill-type plugin maintained by dhicoc, with its repository on GitHub: dhicoc/dsh-reverse-skill. The npm package name is @dhicoc/dsh-reverse-skill, the current package.json version is 1.0.3, and the license is MIT (copyright notice matches the upstream package, marked as zhaoxuya520). The GitHub API showed 27 stars for this repository on 2026-08-17; the community directory page still shows 10 stars, and the numbers may lag behind.

It does not solve the problem of “writing another set of reverse engineering tutorials”, but instead registers the pre-written skill files from the upstream repository using dsh’s ctx.skills interface:
- Upstream repository: zhaoxuya520/reverse-skill (approximately 25,908 stars, MIT license)
- Packaging result: 85 SKILL.md files = 43 domain skills under skills/ + 42 CTF track skills under CTF-Sandbox-Orchestrator/
- Runtime form: Cordis plugin that registers a SkillProvider named reverse-skill on startup

The repository README clearly states that the content is only for authorized reverse engineering, penetration testing, and security research; users must ensure they have legal authorization for the target system. Unauthorized behavior has no connection to this repository.

The plugin’s core code is written in TypeScript (src/index.ts). GitHub marks the primary language as PowerShell because the package includes upstream scripts and skill resources, which does not mean the plugin entry point is PowerShell.

Core Features¶

Complete Port, No Selective Trimming¶

The README breaks down the number 85: there are 43 actual SKILL.md files in skills/ (the number of files after deduplication from the upstream promotion of “60+ domains”), plus 42 in the CTF orchestrator. It is a one-to-one match with the upstream repository, with no content cut.

The domain coverage is broad, and you can see these directions in the module table of the entry skill reverse-skill-router (only categories listed, no detailed operations):
- Mobile and binary: APK, iOS / mobile, .NET, IDA, Ghidra, radare2, Go / Rust, macOS
- Frontend and protocol: JS reverse engineering, browser extensions, custom protocols
- Security research: malware analysis, code audit, digital forensics, API / supply chain / LLM security
- Competitions: Web / reverse / Pwn / forensics and other track skills under CTF-Sandbox-Orchestrator/

The repository README also compared the community’s dsh-reverse-security: according to that README, the latter only ported 45 skills, and it is only preset-only without a Cordis plugin entry. This article did not open that repository for line-by-line verification, and the comparison numbers are based on the dsh-reverse-skill README.

Data-Driven Registration, No Hardcoded List¶

src/index.ts does not maintain a list of skill names. When loading, it will:
1. Recursively traverse skills/ and CTF-Sandbox-Orchestrator/ to find every SKILL.md
2. Parse the YAML front matter (handling UTF-8 BOM, normalizing CRLF; promoting metadata.user-invocable to a top-level field, converting when_to_use to dsh-compatible whenToUse)
3. Construct a SkillCandidate with resourceBase (the directory where the skill is located)
4. Register a provider named reverse-skill via ctx.skills.registerProvider(...); list() returns the directory, and get() reads the content on demand

Adding or deleting skills only requires modifying the directory, and the plugin will scan them automatically. The repository’s self-test _selftest.mjs compiles the plugin, runs through registerProvider in practice, asserts that there are 85 packaged skills, no duplicate names, non-empty content, and additionally includes a fixture file with BOM + CRLF to confirm the scanner will not silently skip such files.

Two Usage Modes: Plugin First, Preset as Backup¶

The recommended path is to use it as a Cordis plugin. The repository declares dsh.bundle, and the patch file is cordis.patch.yml, which will insert the plugin id reverse-skill and package name @dhicoc/dsh-reverse-skill into the current profile.

If you do not want to go through the plugin build process for the time being, you can also mount the two directories as presets (no npm run build required):

skills:
  local:
    customSkillDirs:
      - "./dsh-reverse-skill/skills"
      - "./dsh-reverse-skill/CTF-Sandbox-Orchestrator"

Note that dsh’s skill discovery is flat and does not support recursive **/SKILL.md. So the original upstream skills/SKILL.md was restructured in this repository into a directory structure like skills/reverse-skill-router/SKILL.md. The discovery priority (first match takes effect) per the README is: project .dsh → project .agents → customSkillDirs → user .dsh → user .agents.

Installation and Activation¶

The installation command given on the community directory page can be run in the DeepSeek Harness terminal:

dsh plugin add github:dhicoc/dsh-reverse-skill

The directory page also reminds users that the plugin runs with the permissions of the current dsh process, and may execute code during installation. Please check the source code repository and license before installing. For reproducible installation, pin the commit hash:

dsh plugin add github:dhicoc/dsh-reverse-skill#<commit>

Replace <commit> with the actual commit hash from the repository. Do not use the literal commit from the directory page example.

When building locally from source, the steps in the README are:

npm install
npm run build        # tsc → generates lib/ and lib/types/

The peer dependencies declared in package.json are @deepseek-ai/cordis ^4.0.1 and @deepseek-ai/dsh-skill ^0.0.1-rc.1, which are provided by the dsh runtime. The release artifacts include lib/, skills/, CTF-Sandbox-Orchestrator/, and cordis.patch.yml.

After installation, you can also manually reference the package name in your profile (the README notes that the key name may vary depending on the dsh version; the following is just the example given in the repository):

plugins:
  - "@dhicoc/dsh-reverse-skill"

After loading, apply(ctx) will register the 85 skills into ctx.skills. The model can call them automatically via ctx.skills → tool-skill; whether users can manually call them by skill name depends on the user-invocable field in each SKILL.md.

Optional self-test (run in the root directory of the cloned repository):

npm test

Typical Usage¶

This plugin installs methodological skills, not a toolbox that performs unauthorized scans for you. After installation, the common usage is to assign authorized analysis tasks to dsh and let the routing skill select the modules.
1. Confirm authorization and scope first. The upstream routing contract requires that when auth is not granted, ACT on the target is prohibited. The plugin only brings this contract into dsh and will not obtain authorization for you.
2. Let the model follow the routing instead of calling an obscure skill by name. The entry skill name is reverse-skill-router. When the task spans modules or you are unsure which skill to use, start with it first. It will require reading MASTER-ROUTING.md (or running the master-route script) to determine the PRIMARY, then open the corresponding submodule’s SKILL.md.
3. Select modules by file type instead of loading all 85 documents at once. For example, when analyzing an APK in an authorized lab, the routing will point to apk-reverse/; binary reconnaissance points to radare2 / Ghidra / IDA-related skills; CTF challenges point to CTF-Sandbox-Orchestrator/. Skill content is fetched on demand via get() and will not be fully injected into the context at startup.
4. Prepare native tools and MCPs separately. The skills reference common analysis tools such as jadx, Frida, Ghidra, and MCPS such as Burp. The plugin README clearly states that external MCPs in the skill text (such as burp-mcp) are not within the scope of this plugin, and you need to connect them yourself according to dsh’s mcp.servers. When tools are missing, the skill documentation points to the upstream bootstrap manifest instead of having this Cordis plugin install them on your behalf.

Do not interpret “installing the plugin” as “the agent can arbitrarily attack online systems”. Scope, authorization, and evidence chain are still written in the ops contract of each skill itself.

Applicable Scenarios and Notes¶

It is more suitable for:
- Users already using DeepSeek Harness who want to connect the reverse-skill skill library to ctx.skills instead of manually maintaining directory lists
- Users conducting authorized APK / binary / frontend encryption analysis, CTFs, code audits, malware analysis, etc., who need repeatable skill routing
- Users who require reproducible installation (pinning commits) and can verify that all 85 skills can be discovered with one npm test

Before using, be sure to understand these restrictions (all from the plugin README, not speculation):
1. Permissions and security. The plugin runs with the permissions of the current dsh process. Before installing, you should read src/index.ts, cordis.patch.yml, and the included SKILL.md files to confirm that the license is acceptable.
2. Only for authorized scenarios. Unauthorized scanning and unauthorized intrusion are not within the scope of this plugin.
3. agents/*.yaml are not portable. The 43 OpenAI Agents SDK agent definitions from the upstream repository cannot be mapped to dsh’s ctx.subagent (dsh only supports launching Codex / Claude Code CLI), so these definitions are not included in the plugin.
4. allowed-tools / disallowed-tools are not enforced by dsh. Currently, dsh treats these two fields as unknown and delays execution. Tool constraints in skills must be guaranteed at the harness layer yourself.
5. Front matter fields have been modified. Fields that do not conform to dsh’s camelCase requirements (such as when_to_use) are uniformly converted to whenToUse, user-invocable, etc., by port.py in the repository. Relative links in the text have also been adjusted to paths compatible with flat mounting.
6. The license is not entirely MIT. The root LICENSE file of the plugin is MIT. The upstream README additionally states that CTF-Sandbox-Orchestrator/ uses GNU GPLv3; some external tools (jadx, Frida, Burp, etc.) have their own respective licenses. You should verify this yourself before redistribution or commercial use.
7. Skills are not sandboxes. After installation, the model may still call native tools according to the skill text. Do not enable it blindly in production environments or on untrusted repositories.

Summary¶

The value of dsh-reverse-skill is very concrete: it turns the verified 85 SKILL.md files into a Cordis plugin that dsh can load, eliminating the need for handwritten lists and incomplete ports. It does not provide new attack capabilities, only skill routing and documentation for authorized security research scenarios.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-reverse-skill/

GitHub: https://github.com/dhicoc/dsh-reverse-skill

Upstream skill pack: https://github.com/zhaoxuya520/reverse-skill

Use dsh-reverse-skill to load 85 reverse skills into DeepSeek Harness at once