Security hardening

Hardens code with a short threat model, always, ask-first and never rules, and patterns for injection, XSS, access control, SSRF, secrets, dependencies, personal data and LLM output. Use when code handles user input, auth, sensitive data or outside services.

SecurityPack: Agent Skills by Addy Osmani216 linessecurity-and-hardening
Author
Source
addyosmani/agent-skills/skills/security-and-hardening @ 8c99fa3
License
MIT · Copyright (c) 2025 Addy Osmani

About this skill

What it does

The skill treats security as a constraint on the code, not a later phase. Before hardening, the agent spends five minutes on a threat model: where untrusted data enters (LLM output and values another process wrote included), which assets are worth stealing, a STRIDE pass over each boundary, and abuse cases next to use cases — the first one becomes the first test.

Rules come in three tiers. Always: validate input at the boundary, parameterize queries, encode output, hash passwords, set security headers, audit dependencies before release. Ask first: new auth flows, new kinds of sensitive data, CORS changes, uploads, elevated roles. Never: secrets in git or logs, eval or innerHTML on user data, auth tokens in localStorage, stack traces shown to users. Further sections cover SSRF, deletes on derived paths, rate limiters on a shared store, the supply chain (install scripts blocked until reviewed, and no automatic npm audit fix --force: each upgrade is previewed and tested first), personal data under GDPR and CCPA, and LLM features mapped to the OWASP LLM Top 10.

The folder ships references/hardening-patterns.md with worked examples for most of the rules: bcrypt and session cookies, an ownership check, helmet and CORS, zod validation, an SSRF guard, a Redis-backed limiter, a staged-diff secret check, plus a triage tree for audit findings and a data-classification table. Deletes on derived paths get the reasoning there but no code: their worked example, like the sign-off checklist, is in ../../references/security-checklist.md in the author's repository and is not installed.

When to use it, and when not

Use it while building anything that takes user input, handles login or sessions, stores personal or payment data, accepts uploads or webhooks, or calls third-party APIs or an LLM, and before a release.

The skill lists no exceptions; a change that crosses none of these boundaries gives it nothing to check.

How to run it

The install command below puts SKILL.md, the patterns file and the licence in place. The agent picks the skill up by its description when code touches input, auth, data or dependencies; to call it yourself:

  • Claude Code: /security-and-hardening, or ask for the skill by name.
  • Codex: $security-and-hardening.
  • Cursor: type / in the Agent chat and pick security-and-hardening.

Example: /security-and-hardening Add password reset to the login flow and check it against the OWASP Top 10.

For a privacy incident the skill hands the postmortem to Debugging and error recovery.

How it differs from similar skills

Security review audits a finished diff: it traces each untrusted input to a sink and reports only findings with an attacker, an input and an outcome. This skill works while the code is written and adds the threat model, supply chain, privacy, LLM rules and code patterns. Env and config audit goes deeper on one topic: secrets in code and git history. Security best-practice review also guides writing secure-by-default code, but from per-framework rule files for Python, JavaScript/TypeScript and Go, and only when asked explicitly. Repository threat model turns the five-minute threat model into a full report: trust boundaries, assets and ranked abuse paths.

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/security-and-hardening/SKILL.md https://anymodel.org/en/skills/addy-osmani/security-and-hardening/SKILL.md -o ~/.claude/skills/security-and-hardening/LICENSE https://anymodel.org/en/skills/addy-osmani/security-and-hardening/LICENSE -o ~/.claude/skills/security-and-hardening/references/hardening-patterns.md https://anymodel.org/en/skills/addy-osmani/security-and-hardening/references/hardening-patterns.md
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/security-and-hardening/SKILL.md https://anymodel.org/en/skills/addy-osmani/security-and-hardening/SKILL.md -o ~/.agents/skills/security-and-hardening/LICENSE https://anymodel.org/en/skills/addy-osmani/security-and-hardening/LICENSE -o ~/.agents/skills/security-and-hardening/references/hardening-patterns.md https://anymodel.org/en/skills/addy-osmani/security-and-hardening/references/hardening-patterns.md
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE','references/hardening-patterns.md') { $p = Join-Path "$HOME\.claude\skills\security-and-hardening" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/security-and-hardening/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE','references/hardening-patterns.md') { $p = Join-Path "$HOME\.agents\skills\security-and-hardening" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/addy-osmani/security-and-hardening/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/addy-osmani/security-and-hardening/SKILL.md

SKILL.md

Raw

Security and Hardening

Overview

Security-first development practices for web applications. Treat every external input as hostile, every secret as sacred, and every authorization check as mandatory. Security isn't a phase — it's a constraint on every line of code that touches user data, authentication, or external systems.

When to Use

  • Building anything that accepts user input
  • Implementing authentication or authorization
  • Storing or transmitting sensitive data
  • Integrating with external APIs or services
  • Adding file uploads, webhooks, or callbacks
  • Handling payment or PII data

Process: Threat Model First

Controls bolted on without a threat model are guesses. Before hardening, spend five minutes thinking like an attacker:

  1. Map the trust boundaries. Where does untrusted data cross into your system? HTTP requests, form fields, file uploads, webhooks, third-party APIs, message queues, and LLM output — plus the local values that look internal because the OS handed them to you: another process's command line or environment, filenames on a shared volume, a path in a job payload. Trust follows who wrote a value, not which channel delivered it. Every boundary is attack surface.
  2. Name the assets. What's worth stealing or breaking? Credentials, PII, payment data, admin actions, money movement.
  3. Run STRIDE over each boundary — a quick lens, not a ceremony:
Threat Ask Typical mitigation
Spoofing Can someone impersonate a user/service? Authentication, signature verification
Tampering Can data be altered in transit or at rest? Integrity checks, parameterized queries, HTTPS
Repudiation Can an action be denied later? Audit logging of security events
Information disclosure Can data leak? Encryption, field allowlists, generic errors
Denial of service Can it be overwhelmed? Rate limiting, input size caps, timeouts
Elevation of privilege Can a user gain rights they shouldn't? Authorization checks, least privilege
  1. Write abuse cases next to use cases. For each feature, ask "how would I misuse this?" — then make that your first test.

If you can't name the trust boundaries for a feature, you're not ready to secure it. This is OWASP A06:2025 Insecure Design — most breaches begin in design, not code.

The Three-Tier Boundary System

Always Do (No Exceptions)

  • Validate all external input at the system boundary (API routes, form handlers)
  • Parameterize all database queries — never concatenate user input into SQL
  • Encode output to prevent XSS (use framework auto-escaping, don't bypass it)
  • Use HTTPS for all external communication
  • Hash passwords with bcrypt/scrypt/argon2 (never store plaintext)
  • Set security headers (CSP, HSTS, X-Frame-Options, X-Content-Type-Options)
  • Use httpOnly, secure, sameSite cookies for sessions
  • Run the detected package manager's native audit against the committed lockfile before every release

Ask First (Requires Human Approval)

  • Adding new authentication flows or changing auth logic
  • Storing new categories of sensitive data (PII, payment info)
  • Adding new external service integrations
  • Changing CORS configuration
  • Adding file upload handlers
  • Modifying rate limiting or throttling
  • Granting elevated permissions or roles

Never Do

  • Never commit secrets to version control (API keys, passwords, tokens)
  • Never log sensitive data (passwords, tokens, full credit card numbers)
  • Never trust client-side validation as a security boundary
  • Never disable security headers for convenience
  • Never use eval() or innerHTML with user-provided data
  • Never store sessions in client-accessible storage (localStorage for auth tokens)
  • Never expose stack traces or internal error details to users

Hardening Controls

The rules below are the workflow; a concrete implementation of each lives in references/hardening-patterns.md. Open the section you need when you reach that code, not before.

Injection, XSS, and access control

  • Parameterize every query. Never build SQL, NoSQL, or shell commands from input strings.
  • Encode output through the framework's auto-escaping. If raw HTML is unavoidable, sanitize with an allowlist sanitizer first.
  • Check authorization on every request, not just authentication: the authenticated user must own, or be permitted on, the specific resource (A01:2025, IDOR).

Patterns: Injection, XSS, Access control.

Authentication and sessions

  • Hash passwords with bcrypt (≥12 rounds), scrypt, or argon2. The session secret comes from the environment, never from code.
  • Session cookies are httpOnly, secure, and sameSite: 'lax' or 'strict' (the CSRF defense; 'none' sends the cookie on cross-site requests), with a bounded maxAge.

Pattern: Authentication.

Headers, CORS, and responses

  • Security headers on every response (helmet or the framework equivalent); CSP starts from default-src 'self' and is tightened, not loosened.
  • CORS restricted to an explicit origin list from configuration. Never * with credentials.
  • Strip sensitive fields (passwordHash, reset tokens) before any response. Error bodies are generic; internals go to server logs only.

Patterns: Misconfiguration, Sensitive data exposure.

Input validation and uploads

  • Validate at the boundary with a schema: allowlisted shape, lengths, enums, formats. Reject with 422 and structured details; downstream code uses only the parsed, typed value.
  • Uploads: allowlist MIME types, cap size, verify content (magic bytes) when it matters. The extension proves nothing.

Patterns: Schema validation, File upload.

Server-side fetches (SSRF)

Any URL the user influences — webhooks, import-from-URL, image proxies, link previews — can be aimed at internal services. Allowlist scheme and host, resolve all DNS records and reject any private or reserved address (loopback, link-local 169.254.169.254, private, unique-local, for IPv4 and IPv6), and forbid redirects. That check still has a DNS-rebinding TOCTOU gap: for high-risk surfaces, pin the resolved IP or put a filtering agent in front.

Pattern: SSRF.

Destructive operations on derived paths

A delete, move, or overwrite is only as safe as the value naming its target, and trust follows who wrote that value, not which channel delivered it: another process's command line is as attacker-controlled as a form field. A shape check proves well-formedness, not authorization. Before the call, require all three: the resolved target (symlinks resolved) sits under an allowlisted root; it is at least one level below that root; and it carries ownership evidence read before the operation. On refusal, log the rejected target and stop; never fall back to a broader default path.

Why the check is weaker than it reads (marker self-attestation, check/use races): Destructive paths. Worked code: ../../references/security-checklist.md.

Rate limiting

Limit the API generally and auth endpoints strictly (about 10 attempts per 15 minutes). Once more than one process serves traffic, in-memory counters silently become max × instances, or never fire on serverless: back the limiter with a shared store.

Pattern: Rate limiting.

Secrets

Secrets come from the environment. .env.example is committed with placeholders; real .env* files and key material are gitignored; grep the staged diff before committing. A secret that reaches a remote is compromised the moment it lands: rotate it first, then purge history.

Pattern: Secrets management.

Dependencies and supply chain

  1. Find the installation boundary and manager. Use the workspace root that owns the lockfile, or an independent nested project only when it is outside that workspace. Corroborate packageManager (when present), the lockfile, and CI; stop on disagreement or competing lockfiles. Pin the manager version.
  2. Block dependency scripts before first execution. Bootstrap with scripts disabled or a documented fail-closed policy, inspect the pending script source, approve only the minimum, commit the policy, then verify with a clean frozen/immutable install. Never blanket-approve.
  3. Run the native audit against the committed lockfile before every release. Triage critical/high by reachability (runtime, build, test, deploy paths) and fix availability. Never apply forced remediation (npm audit fix --force or equivalent) automatically, since forced fixes may cross declared dependency ranges; preview, read changelogs, test each upgrade. Document every deferral with a reason and a review date.
  4. Audits only match known advisories. They do not catch a newly malicious or typosquatted package (cross-env vs crossenv). Review new dependencies, lockfile diffs, and script-policy changes together: ownership, maintenance, release age, provenance, transitive graph. Verify registry signatures where supported (npm audit signatures, pnpm audit signatures) and treat their absence as a signal to investigate, not automatic proof of compromise (A03:2025, LLM03).

Triage decision tree: Dependency audit triage. Manager matrix and install-script gate: ../../references/security-checklist.md.

Personal data and privacy

Hardening asks "can an attacker read it?" Privacy asks "should we hold it at all, and for how long?" The cheapest data to protect, breach, and comply over is the data you never collected; treat personal data as a liability to minimize.

  • Classify fields as you add them (non-personal, PII, sensitive) and handle each class accordingly. You cannot protect, or honor a deletion request for, data you cannot find.
  • Collect only against a stated purpose. "Might be useful later" is latent breach scope, not a purpose. Keep PII out of telemetry (the observability-and-instrumentation skill makes the same point from the ops side).
  • Set retention up front, then actually delete. Every personal-data store needs a TTL and a working deletion path, including backups, caches, search indexes, and analytics copies.
  • Support the data-subject rights your jurisdiction requires (GDPR, CCPA, and kin): export, correct, delete. Design the schema so a user's data is findable and erasable, not smeared irreversibly across systems.
  • Consent gates collection and third-party sharing, and is auditable. Sending PII to an analytics, ad, or LLM vendor is sharing; the vendor needs a data-processing agreement. Make region a configurable policy, not a hardcoded assumption.

Classification table: Data classification. A privacy incident starts the breach-notification clock; run the postmortem with the debugging-and-error-recovery skill.

AI / LLM features

Calling an LLM — chatbots, summarizers, agents, RAG — adds a new attack surface; map it to the OWASP Top 10 for LLM Applications (2025):

  • Model output is untrusted input (LLM05). Never into eval, SQL, a shell, innerHTML, or a file path; parse defensively, validate against a schema, then encode.
  • Prompts can be hijacked (LLM01). Untrusted text in the context — a user message, a fetched page, a PDF — can carry instructions. The system prompt is not a security boundary; enforce permissions in code.
  • Keep secrets, other tenants' data, and the full system prompt out of the context window (LLM02, LLM07); scope tool permissions, validate every tool argument, and confirm destructive actions (LLM06); cap tokens, request rate, and recursion depth (LLM10); partition RAG embeddings per tenant and validate documents before indexing (LLM08).

Pattern: LLM output handling.

Review Checklist

Before sign-off, walk ../../references/security-checklist.md: it covers authentication, authorization, input, data protection and privacy, headers and CORS, dependencies and supply chain, AI/LLM, and error handling, plus the OWASP quick-reference tables.

Common Rationalizations

Rationalization Reality
"This is an internal tool, security doesn't matter" Internal tools get compromised. Attackers target the weakest link.
"We'll add security later" Security retrofitting is 10x harder than building it in. Add it now.
"No one would try to exploit this" Automated scanners will find it. Security by obscurity is not security.
"The framework handles security" Frameworks provide tools, not guarantees. You still need to use them correctly.
"It's just a prototype" Prototypes become production. Security habits from day one.
"Threat modeling is overkill here" Five minutes of "how would I attack this?" prevents the design flaws no control can patch later.
"It's just LLM output, it's only text" That "text" can be a SQL statement, a script tag, or a shell command. Treat it like any untrusted input.
"The audit passed, so the dependency is safe" Audits match known advisories. They do not detect a newly malicious package or make unreviewed install scripts safe to execute.
"Collect it now, we might need it later" Data you don't hold can't be breached, subpoenaed, or mis-deleted. "Might need it" is breach scope, not a purpose.
"We'll handle deletion requests manually" Manual erasure misses backups, caches, and analytics copies. If the schema can't find a user's data, you can't honor the request — design for it.
"Compliance is legal's problem, not ours" Export, deletion, retention, and consent are schema and code. Legal can't bolt them on after you've smeared PII across ten systems.

Red Flags

  • User input passed directly to database queries, shell commands, or HTML rendering
  • A delete, move, or overwrite whose target comes from a payload, a config value, or another process's command line, guarded only by a shape check on the path
  • Secrets in source code or commit history
  • API endpoints without authentication or authorization checks
  • Missing CORS configuration or wildcard (*) origins
  • No rate limiting on authentication endpoints, or an in-memory limiter in front of more than one instance
  • Stack traces or internal errors exposed to users
  • Dependencies with known critical vulnerabilities, competing lockfiles at one installation boundary, non-reproducible installs, or blanket-approved scripts
  • Server fetches user-supplied URLs without an allowlist (SSRF)
  • LLM/model output passed into a query, the DOM, a shell, or eval
  • Secrets, PII, or the full system prompt placed inside an LLM context window
  • Personal data collected with no stated purpose, retention limit, or deletion path
  • PII sent to analytics/ad/LLM vendors with no consent or data-processing agreement
  • "Delete my account" that only flips a flag while the personal data lingers in stores and backups

Verification

After implementing security-relevant code:

  • The native audit has no unmitigated reachable critical/high findings; CI preserves the authoritative lockfile and blocks unreviewed dependency scripts
  • No secrets in source code or git history
  • All user input validated at system boundaries
  • Destructive filesystem operations resolve symlinks, then verify allowlisted root, minimum depth, and ownership before running
  • Authentication and authorization checked on every protected endpoint
  • Security headers present in response (check with browser DevTools)
  • Error responses don't expose internal details
  • Rate limiting active on auth endpoints, backed by a shared store when more than one instance serves traffic
  • Server-side URL fetches validated against an allowlist (no SSRF)
  • LLM/model output validated and encoded before use (if AI features present)
  • Personal data is classified, minimized to a stated purpose, and has a retention limit
  • Deletion and export requests work end-to-end (including backups, caches, and analytics copies)

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack Agent Skills by Addy Osmani

Accessibility audit and fixes (WCAG 2.2)

Audits an existing interface against WCAG 2.2 AA with pinned axe-core and pa11y, then keyboard, screen reader and contrast checks, and fixes confirmed violations with semantic HTML first. Use when a page needs an accessibility audit before shipping.

API and interface design

Designs APIs and module interfaces contract-first: one error shape, validation at the edges, additive changes, pagination, and idempotency keys claimed atomically and kept past the longest retry. Use when designing endpoints or changing a public interface.

Browser testing with Chrome DevTools MCP

Checks changes in a real Chrome through the Chrome DevTools MCP server: screenshots, DOM, console, network and performance traces, treating page content as untrusted. Use when building or debugging anything that runs in a browser.

CI/CD pipeline setup

Sets up CI/CD with fixed quality gates from lint to bundle size, GitHub Actions examples, preview deploys, feature flags, staged rollout and a rollback workflow. Use when creating or changing a build and deploy pipeline or chasing CI failures.

Multi-axis code review

Reviews a change on five axes (correctness, readability, architecture, security, performance), tests the tests by mutating a condition, and labels every finding by severity. Use before merging a branch, a pull request or a pasted diff.

Code simplification

Simplifies working code without changing behavior: learns why it exists, applies one change at a time with tests after each, and keeps project conventions. Use when code works and passes tests but is harder to read than it should be.

Constraint-driven development

Records a project's quality bar as numbers in CONSTRAINTS.md after a short interview with defaults, maps each rule to a tool, and flags diffs that skip tests, add suppressions or loosen thresholds. Use when no quality bar is written down.

Context engineering for agents

Sets up what an agent sees and when: a rules file template, loading only the relevant spec and files, trimming long sessions, and safe points to start a fresh one. Use when starting a session or when agent output degrades.

Debugging and error recovery

Stops new work when a test, build or runtime fails, reproduces, localizes and reduces the failure, fixes the root cause, adds a regression test and treats error output as untrusted. Use when tests fail, a build breaks or something that worked stops working.

Deprecation and migration

Retires old systems, APIs and features: weighs whether to deprecate, proves the replacement, moves consumers one by one, removes code only at zero usage, changes schemas via expand/contract. Use when replacing or sunsetting code or renaming a live column.

Documentation and ADRs

Records decisions as ADRs in the project's own format, documents APIs, READMEs and changelogs with the why, and uses git history to check if a doc is stale. Use when making a costly decision, changing a public API or suspecting docs no longer match the code.

Doubt-driven development

Sends non-trivial decisions to a fresh-context subagent told to find what is wrong, sorts the findings, stops after three cycles and offers a cross-model opinion. Use when stakes are high: auth, migrations, irreversible operations or unfamiliar code.

Frontend UI engineering

Builds UI components and pages on the project's design system: composition, simple state, WCAG 2.1 AA, mobile-first layouts, loading, empty and error states, no generic AI look. Use when building or changing a user-facing interface.

Git workflow and versioning

Keeps git work in atomic commits on short-lived branches, with typed messages, a pre-commit check for secrets and tests, worktrees for parallel agents, semver bumps, tags and a human changelog. Use when committing, branching, opening a PR or cutting a release.

Idea refinement

Refines a raw idea in three phases: sharpening questions and five to eight variations, two or three directions tested for value and feasibility, then a one-pager with MVP scope and a Not Doing list. Use when an idea is vague or a plan needs stress-testing.

Incremental implementation

Builds changes in thin vertical, contract-first or risk-first slices, each tested, verified and committed before the next, with strict scope, feature flags and revertable steps. Use when a change spans several files or a task is too big to land in one step.

Interview me

Interviews the user one question at a time, each with a guessed answer and a confidence number, until the agent can predict the next replies, then confirms a statement of intent before any spec or code. Use when a request leaves who, why or success unclear.

Observability and instrumentation

Instruments a feature with structured JSON logs and request IDs, RED and USE metrics with bounded labels, OpenTelemetry traces and symptom-based alerts with runbooks, then tests the telemetry. Use when a feature, job or integration is headed for production.

Performance optimization

Optimizes by measurement: takes a baseline, fixes the one proven bottleneck, re-measures against noise and reverts neutral changes, with worked fixes for N+1 queries, indexes, caching and bundles. Use when something is slow or misses a performance budget.

Planning and task breakdown

Breaks a spec into small vertical-slice tasks with acceptance criteria, verification steps, sizes, dependency order and checkpoints, saved to tasks/todo.md or a named tracker. Use when a spec is ready but the work is too big to start in one go.

Shipping and launch

Prepares a production launch with a pre-launch checklist, a feature-flag rollout from 5% to 100%, thresholds for advancing or rolling back, an error-budget gate, a rollback plan and first-hour checks. Use when a feature or major change is about to ship.

Source-driven development

Grounds framework code in official docs: reads exact versions from the dependency file, fetches the relevant page, follows the documented API and cites full URLs, flagging anything unverified. Use when framework-specific code must match the version in use.

Spec-driven development

Writes a spec before code, surfacing assumptions and covering objective, commands, structure, style, tests and boundaries, then gates plan, tasks and code on approval, with capability maps and delta specs. Use when new work has vague requirements.

Test-driven development, red-green-refactor

Drives changes with red-green-refactor: finds the repository's own test commands, writes the failing test first, reproduces each bug with a test before fixing it, and sets rules on mocks and naming. Use when adding logic, fixing a bug or changing behavior.