Skip to content
Agentmart
Submit a tool

harden

Security audit: threat model, OWASP Top 10 (and LLM Top 10), abuse cases, dependency and secret scan, with ranked findings and concrete fixes.

Skill by saleh-alhaddad

IndexedMIT★ 12
Write a review

Chalk Labs

Need help deploying harden?

Chalk Labs sets up agents like this inside real teams: connected to your tools, tested on your data, with a human in the loop where it matters.

Book a call

Install

Works with Claude Code, Claude apps, Codex, Cursor, Gemini CLI, GitHub Copilot, VS Code, OpenCode, Goose, Windsurf. Read the repository before you give any tool access to your data.

npx agentmarket install skill/saleh-alhaddad-harden

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

We use your email only for this newsletter. Privacy

About

Security audit: threat model, OWASP Top 10 (and LLM Top 10), abuse cases, dependency and secret scan, with ranked findings and concrete fixes. Read-only.

Use cases: ml, security

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this skill can do and what it asks for, from its SKILL.md and code. Checked Oct 25, 2026.

Tools
No tools found
Secrets
None asked for
Install scripts
None found

Network hosts it talks to 1

  • codeload.github.com · found in install command

Files it touches

  • ~/.claude/skills/harden

What's inside

Skill name
harden
Description
Security audit: threat model, OWASP Top 10 (and LLM Top 10), abuse cases, dependency and secret scan, with ranked findings and concrete fixes. Read-only.
License
MIT
Instructions
160 lines in SKILL.md · view on GitHub

Files (1)

  • SKILL.md

SKILL.md (first lines)

# harden — dedicated security review

Look at the system the way an attacker would, then report what a defender must fix. This is
the focused security pass; `inspect` covers general quality with a security *axis*, but a
real hardening review deserves its own depth.

Read [references/disciplines/security.md](../../references/disciplines/security.md) — the
shared security reference (STRIDE, OWASP Top 10 + LLM Top 10, secrets, abuse cases). Read
[CONVENTIONS.md](../../CONVENTIONS.md) for the workspace (§1), the ledger (§2), judgment (§4.1), the resume sweep (§5), git isolation (§11), multi-agent
rules (§8), grounding (§14), and freshness (§17 — check current CVEs/advisories against
today's date), and workspace integrity (§20).

**Journal every run (§2.1).** The first write of the run, once the task folder is resolved
(§20.1), is a START entry in the task's `log.md`; then set this phase `in_progress` in
`state.json`. Append a DECISION entry before acting on any choice that shapes the work, and
a STOP entry before every reply that ends the turn. Write only the files the workspace tree
names (§1): nothing lost, nothing stray. Before asking a question or deciding, check the
user's judgment (§4.1) for a confirmed rule that covers it, and journal who decided.

## Step 1 — Scope & threat model

**The iron rule: no finding without a reachable path from an attacker to an asset.** A
checklist item that fails in the abstract is not a finding until you can name who reaches it
and what they get. Build the model before auditing, in this order:

1. **Assets** — what is actually worth stealing or breaking here? Credentials, personal data,
   money movement, the ability to act as another user, availability. Rank them; the audit's
   attention follows this list, not the checklist's order.
2. **Entry points** — every place untrusted input enters: routes and handlers, webhooks,
   queue consumers, file/image uploads, third-party callbacks, admin surfaces, CLI flags,
   environment and config. **The API is the surface, not the UI** — enumerate endpoints from
   the router, never from the screens.
3. **Actors and their starting privilege** — anonymous · self-registered user · another
   tenant's user · low-privilege staff · compromised dependency · someone with a stolen
   session. For each finding later, you will name which of these can reach it.
4. **Trust boundaries** — draw the lines where data crosses from one privilege level to
   another. Every boundary is a place validation and authorization must exist; missing checks
   cluster there.
5. **STRIDE per boundary** — spoofing · tampering · repudiation · information disclosure ·
   denial of service · elevation of privilege. Walk the six against each boundary and keep
   what is concrete for *this* system.

Load `security.md` for the checklist that the audit works through.

## Step 2 — Audit (read-only)
Work the checklist against the code and config:
- **Access control** — authz on every route/action, deny-by-default, no IDOR.
- **Injection & input** — parameterized queries, boundary validation.
- **Crypto & secrets** — TLS, encryption at rest, strong hashing; no secrets in code/logs
  (scan the diff).
- **Auth & sessions** — rate-limited login, safe session/JWT handling.
- **Dependencies/supply chain** — known-vulnerable packages (web-check current advisories, §17).
- **SSRF, deserialization, misconfig, debug endpoints.**
- **LLM features** — prompt injection, unsafe tool permissions, data leakage.

In multi-agent mode, dispatch parallel auditors by category and merge; the orchestrator owns
writes (§8). Single-agent: work the checklist inline with fresh eyes.

**These thoughts mean stop — you are about to dismiss a real finding:**

| The thought | The reality |
|---|---|
| "It's internal-only, not exposed" | Internal networks get breached: model a **network-internal attacker** too. But rank by who can reach it, verified, not by the worst case imagined. |
| "You'd have to be logged in to hit it" | Check whether anyone can register (the signup route or its config, cited). Authenticated ≠ trusted either way. |
| "Another tenant couldn't reach this" | That is the claim to *test*, not assume — it is the definition of IDOR. |
| "No one would think to try that" | Attackers do this full-time and share notes. |
| "It's validated on the client" | Client validation is UX. The server is the boundary. |
| "That endpoint is old, nobody uses it" | Unused, reachable, and unmaintained is the ideal target. |
| "The framework probably handles it" | Probably is not a control. Read the config and confirm. |

Dismissing a finding is a decision with the same weight as raising one — it needs the same
evidence.

## Step 3 — Report
Write `security-review.md` in the task folder (bootstrap per §1), ranked by severity:

```
# Security review — <target> · <date>
### Coverage — entry points reviewed (file:line), and for each checklist item the read or
                search that cleared it (absence claims show their searches, §5.2)
### Critical  — exploitable now: <boundary violated> → <impact> → <fix>
### High      — exploitable given a verified precondition / sensitive-data exposure
### Medium    — defense-in-depth gaps
### Info      — hardening suggestions
```

Every finding carries its **evidence**: a **source-to-sink trace** (where untrusted input
enters, file:line, through each step, to the dangerous operation, file:line) and its
**reachability, verified** (the route, the auth guard or its absence, the signup config,
cited). That is enough to rank it: `harden` reads and does not attack, so a traced,
reachable hole is ranked by the table above even though nothing was fired. A path with a step
you could not trace is labelled a **hypothesis**, and says which step is missing; unverified
reachability takes the lower rank, labelled unconfirmed. A committed secret is ranked by
what it grants, never "reproduced" by using it: when the grants cannot be confirmed without
using it, rank by what its name and location indicate (a key in `prod.env` grants production
access), labelled unconfirmed, and let the user confirm.

**Calibrate severity by reachability × impact, not by how alarming the category sounds.** When
the two columns point at different rows (reachable by anyone, but the impact reads like the
High row), take the more severe row and say which column set it:

| Rank | Who can reach it | What they get |
|---|---|---|
| **Critical** | anonymous, or any self-registered user | auth bypass · RCE · another tenant's data · money movement · mass data exposure |
| **High** | authenticated, or a precondition shown to hold | a single user's sensitive data · privilege escalation within a tenant · destructive action |
| **Medium** | needs an unlikely chain, or is a missing layer behind a working control | defense-in-depth gap · information leak that aids a bigger attack |
| **Info** | not reachable today | hardening that prevents a future mistake |

A category does not set the rank — a hardcoded key in a repo nobody can read is not Critical,
and a missing authorization check on one route is not Info.

A finding is valid only with a **violated boundary + demonstrated impact + a concrete fix**,
and each one names **which actor reaches it** (Step 1) — no speculative "could be risky".
Never invent a CVE or a vulnerability — verify and cite, or label it a hypothesis to confirm
(§14). **No secret is ever written into the report**: name the file and line, never the
value, and if a live credential is found say so plainly and treat rotation as part of the
fix — a leaked secret that was committed is already public to anyone with repo history.

## Step 3b — Variant analysis (report the class, not the instance)

From saleh-alhaddad/itqan-engineering, MIT.

Signals

Stars
12
Forks
0
Open issues
0
Last commit (this folder)
Sep 29, 2026 (1 month ago)
Last release
Sep 1, 2026 (2 months ago)

From GitHub (fetched Oct 24, 2026).

Details

License
MIT
First seen
Oct 24, 2026
Last checked
Oct 24, 2026

Done for you

Rather not set it up yourself?

Chalk Labs scopes, builds and runs agents for your team: the task audit, the eval harness, the integrations and the weekly ops report. Fixed scope, priced before we start.

See how we build AI agents →Read the case studies

Chalk Labs is a two-founder AI and growth studio. We build AI agents, CRMs and MVPs for Web3 and AI companies, and have shipped 50+ product and token launches.

launches shipped
50+
launches shipped
media placements
500+
media placements
founders on every account
2
founders on every account

Press we've placed: Forbes · CoinDesk · Decrypt · Cointelegraph · The Block

Rahil Jain, Co-founder, Chalk Labs. Ex-Goldman Sachs engineer. You talk to the person who builds it.

Get harden running in your business

Tell us what you want to automate. A founder replies within one working day with a plan, not a pitch deck.

Goes to the Chalk Labs founders, not the newsletter. Privacy

Need help deploying harden?

CallGet help
Cite this page

harden skill. Agent Mart. https://agentmart.dev/skills/saleh-alhaddad-harden (last updated 2026-10-24)