convez.ai
SkillSegurançaAvançado
mitulpatelp112-svg

Fortify

mitulpatelp112-svg/fortify

Audita, fortalece e prova a segurança com testes de ataque autorizado

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill de segurança universal para Claude Code que audita, fortalece e testa qualquer projeto (web, API, mobile, desktop) contra frameworks OWASP, NIST, CIS, SOC 2 e PCI-DSS. Após corrigir vulnerabilidades, comprava a efetividade das correções através de testes de ataque autorizado com agentes inteligentes.

Instalação

$npx convez-ai mitulpatelp112-svg/fortify

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
0
Acompanhando
0
Saúde
57%
Último commit
há 4 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Auditoria de segurança automatizada em projetos de qualquer stack
  • Testes de penetração autorizados contra ambientes locais e staging
  • Mapeamento de superfície de ataque e compliance com frameworks regulatórios
  • Validação de correções de vulnerabilidade com red-team agents

Veredito

Fortify é uma solução robusta que transforma segurança de uma atividade pontual em fluxo de trabalho repetível. A capacidade de testar automaticamente as correções aplicadas com agentes de ataque autorizado é diferencial real; exige, porém, ambiente controlado e aprovação explícita para execução.

README

A tradução para o português deste README ainda está na fila.

🛡️ Fortify

A universal cybersecurity skill for Claude Code that hardens any project — then proves it by attacking it.

License: MIT OWASP Frameworks Defensive


The problem it solves

Most teams ship code without ever asking the two questions an attacker asks first: "What's exposed?" and "What happens if I poke it?" Security reviews are expensive, inconsistent, and usually happen too late — if at all. Findings come as a PDF nobody actions, with no proof the fix actually closed the hole.

Fortify turns security from a one-off audit into a repeatable, project-agnostic workflow you can run on any codebase:

  1. It maps your attack surface — exactly what is accessible vs. protected, and to whom.
  2. It audits against a comprehensive attack catalog (OWASP Top 10 and well beyond).
  3. It hardens the code (report-first, fix-on-approval), mapped to the compliance frameworks you care about.
  4. It proves the hardening holds by unleashing a swarm of authorized attacker agents against your own running app.
  5. It reports in Markdown + JSON + SARIF, with a before/after and an honest residual-risk statement.

It works on web apps, REST/GraphQL APIs, mobile, and desktop projects — it detects the stack itself, so there's nothing to configure to get started.

Defensive by design. Active testing only runs against systems you own or are explicitly authorized to test (localhost / confirmed staging), is non-destructive by default, and never echoes secrets or live PII.

Table of contents

Quick start

Try it against the bundled intentionally-vulnerable demo app:

git clone https://github.com/mitulpatelp112-svg/cybersecurity-.git
cd cybersecurity-/demo-app
npm install
npm start          # vulnerable app on http://localhost:3000 (localhost only!)

Then, in Claude Code (this repo already ships the skill), run:

/fortify

Fortify will confirm authorization, detect the Express app, ask which security tier you want, audit demo-app/src/, show you the findings, harden on your approval, then attack localhost:3000 to confirm the fixes hold.

Install into your own project

# from a clone of this repo:
.claude/skills/fortify/scripts/install.sh /path/to/your/project

This copies the skill to your-project/.claude/skills/fortify/. Open that project in Claude Code and run /fortify.

How it works

Fortify runs as a phased workflow (see SKILL.md):

PhaseWhat happens
0 · AuthorizeConfirms you own the target; locks live testing to localhost / confirmed staging.
1 · DiscoverDetects stack, enumerates entry points, drafts the Accessibility Map.
2 · Choose levelYou pick a tier + fix policy + compliance frameworks (asked interactively).
3 · Audit & threat-modelWalks the code against the attack catalog, STRIDE per entry point.
4 · Report (gate)Severity-ranked findings + remediation; you decide what to fix.
5 · HardenApplies idiomatic fixes on approval, re-runs your tests/build.
6 · Red-team swarmParallel specialized attacker agents safely attack the authorized target.
7 · Final reportMarkdown + JSON + SARIF, updated Accessibility Map, residual risk, optional CI gate.

Security tiers

You choose how deep to go per run (full details in security-tiers.md):

TierForAdds
Basicprototypes, internal toolsOWASP essentials, parameterized queries, no secrets in source, TLS
Standardmost public apps/APIsfull OWASP Top 10 + API Top 10, authN/Z hardening, headers, CSRF, rate limits
Hardenedsensitive/regulated datathreat model, supply-chain & secrets mgmt, crypto review, CIS infra hardening
Maximumhigh-value / defense-gradezero-trust, assume-breach, DoS resilience, advanced/APT scenarios, detection & response

"High-end security that nobody can access" is an aspiration, not a guarantee. Maximum tier means defense-in-depth that makes attacks expensive, slow, and loud — and ensures you detect and recover. Fortify always states residual risk.

Usage examples

Audit only, no changes:

"Run fortify on this repo at the Standard tier, report-only — don't change anything yet."

Harden a specific concern:

"Use fortify to find and fix all injection and access-control issues, then prove the fixes with the red-team swarm against localhost:8080."

Ship-readiness check:

"Is this safe to ship? Run fortify at Hardened tier, map it to SOC 2 and OWASP ASVS, and tell me what's still exposed."

Add a CI gate:

"Run fortify, then install the security CI workflow so PRs get scanned automatically."

A full annotated walkthrough — including a sample findings report and accessibility map for the demo app — lives in docs/EXAMPLE-RUN.md.

What you get out

Each run writes to security/ in the target project:

  • report.md — executive summary + technical appendix + accessibility map.
  • findings.json — machine-readable, conforming to findings.schema.json.
  • findings.sarif — SARIF 2.1.0 so findings show inline on GitHub PRs (code scanning).

Plus an Accessibility Map answering, for every surface: who can reach this, with what auth, and is that intended?

Repository layout

.
├── .claude/skills/fortify/        # the portable Fortify skill
│   ├── SKILL.md                   # phased orchestrator
│   ├── references/                # attack catalog, tiers, compliance, playbooks, reporting
│   ├── agents/red-team-swarm.md   # authorized attacker-agent orchestration
│   ├── templates/                 # auth checklist, findings schema, report, CI workflow
│   └── scripts/install.sh         # copy Fortify into any project
├── demo-app/                      # intentionally-vulnerable app + hardened version
├── docs/EXAMPLE-RUN.md            # annotated end-to-end walkthrough
├── SECURITY.md                    # responsible-use & disclosure policy
└── LICENSE                        # MIT

Safety & ethics

Fortify is a defensive tool. Read and follow authorization-checklist.md before any active testing. In short: only test what you own or are authorized to test; non-destructive by default; never exfiltrate or log secrets/PII; reports are advisory evidence and gap analysis, not a certification, and no tier guarantees invulnerability. See SECURITY.md.

Repository metadata

Suggested values to set in GitHub → repo settings (the API for these isn't available to the skill, so set them once by hand):

  • Description:

    Universal Claude Code security skill: audits, hardens, and authorized-attack-tests any project (web/API/mobile/desktop) against OWASP, NIST, CIS, SOC 2 & PCI-DSS — then proves the fixes hold with a red-team agent swarm.

  • Topics: security · cybersecurity · pentest · penetration-testing · appsec · owasp · owasp-top-10 · security-hardening · red-team · sast · devsecops · claude-code · ai-security · vulnerability-scanner · threat-modeling · nist · compliance

License

MIT © 2026 Mitul Patel

Ver o original no GitHub

Bom para

Relacionados