# Relatórios e compliance

> Relatórios de pentest, triagem de achados, enriquecimento de CVEs, mapeamento de controles e laboratórios de treino.

Mapeamentos para OWASP ASVS e MASTG, NIST CSF, ISO 27001, SOC 2, PCI DSS, GDPR e LGPD, enriquecimento com CVSS, EPSS e KEV, deduplicação, playbooks de remediação e coaching de CTF.

1337: Methodical, concise cybersecurity mode for red/blue/purple operations, research, and low-level development. Use for 1337/elite, a sustained cyber problem-solving posture, or organized cyber investigation state.

achieving-cmmc-level-2-compliance: Prepare a defense-contractor environment for CMMC Level 2 certification: scope CUI and FCI, implement the 110 NIST SP 800-171 Rev 2 security requirements across 14 families, compute the SPRS score with the DoD Assessment Methodology, manage a compliant POA&M, and ready the organization for a C3PAO a

analyzing-cyber-kill-chain: Analyzes intrusion activity against the Lockheed Martin Cyber Kill Chain

analyzing-malicious-office-macros: Analyzes malicious Office documents by extracting and reviewing VBA macros and

analyzing-malicious-onenote-and-html-smuggling: Analyzes two modern delivery techniques: malicious OneNote (.one) attachments with

analyzing-malicious-pdfs: Analyzes malicious PDF documents: parsing the object structure for JavaScript,

analyzing-malicious-url-with-urlscan: URLScan.io is a free service for scanning and analyzing suspicious URLs.

analyzing-mft-for-deleted-file-recovery: Analyze the NTFS Master File Table ($MFT) with MFTECmd, analyzeMFT,

analyzing-position-independent-code: Analyzes position-independent code and shellcode by identifying GetPC/PEB-walk

analyzing-sbom-for-supply-chain-vulnerabilities: Parses Software Bill of Materials (SBOM) in CycloneDX and SPDX JSON

analyzing-threat-actor-ttps-with-mitre-navigator: Map advanced persistent threat (APT) group TTPs to the MITRE ATT&CK framework using the attackcti Python library to query STIX/TAXII data for group-technique associations, then generate ATT&CK Navigator layer files to visualize and compare defensive coverage against adversary profiles. Use when prof

analyzing-threat-intelligence-feeds: Analyzes structured and unstructured threat intelligence feeds to extract

analyzing-uefi-bootkit-persistence: Analyzes UEFI bootkit persistence (SPI flash implants, ESP modifications,

analyzing-webshells: Analyzes suspected webshells (PHP, ASPX/ASP, JSP) by detecting dynamic-execution

asm-patterns: Assembly language patterns, calling conventions, and code structure for x86-64 and ARM64. Use when writing, reviewing, or generating .asm/.s/.S files; when implementing functions that interoperate with C/system code; or when establishing correct prologues, epilogues, stack management, SIMD loops, sy

audit-augmentation: Augments Trailmark code graphs with external audit findings from SARIF static analysis results, weAudit annotation files, and version-gated Trailmark 0.4.x binary-analysis graph exports. Maps findings to graph nodes by file and line overlap, creates severity-based subgraphs, and enables cross-refere

bug-bounty-report-writing: Write bug bounty reports that get triaged quickly and rated accurately — clear impact statements, minimal reproduction steps, and professional tone. Use before submitting any vulnerability report.

building-attack-pattern-library-from-cti-reports: Parse cyber threat intelligence reports (Mandiant, CrowdStrike, Talos, Microsoft) with stix2, mitreattack-python, and spaCy to extract adversary behaviors, map them to MITRE ATT&CK technique IDs, and build a searchable STIX 2.1 attack-pattern library with detection templates. Use when cataloging att

building-phishing-reporting-button-workflow: Implement a phishing report button (Microsoft 365 built-in Report button

building-role-mining-for-rbac-optimization: Apply bottom-up and top-down role mining techniques, including clustering

building-threat-intelligence-feed-integration: Builds automated threat intelligence feed integration pipelines connecting

building-threat-intelligence-platform: Design and deploy a Threat Intelligence Platform (TIP) by integrating open-source CTI tools (MISP, OpenCTI, TheHive, Cortex) into a unified system with feed ingestion pipelines, enrichment workflows, STIX/TAXII interoperability, and analyst dashboards. Use when architecting or standing up a centrali

cleanup-workspace: Clean up the local workspace after a dev branch has been merged into main. Verifies the current dev branch is fully merged into origin/main, then switches to main, pulls the latest, deletes the local dev branch, and deletes the remote dev branch if it still exists. STOPS and warns the user if the cu

code-maturity-assessor: Systematic code maturity assessment using Trail of Bits' 9-category framework. Analyzes codebase for arithmetic safety, auditing practices, access controls, complexity, decentralization, documentation, MEV risks, low-level code, and testing, then produces a scorecard with evidence-based ratings and

collecting-indicators-of-compromise: Systematically collects, categorizes, and distributes indicators of

collecting-volatile-evidence-from-a-suspect-host: Collects volatile evidence from a potentially compromised host in correct order of

conducting-cyber-risk-assessment-with-nist-800-30: Conduct a defensible cybersecurity risk assessment using the NIST SP 800-30 Rev 1 methodology: prepare scope and a risk model, identify threat sources and threat events, identify vulnerabilities and predisposing conditions, determine likelihood and impact, compute risk, and communicate results as a

conducting-gdpr-compliance-assessment: Conduct comprehensive GDPR compliance assessments by evaluating data processing activities against EU Regulation 2016/679, including Article 30 records of processing, lawful basis validation, data subject rights implementation, Data Protection Impact Assessments (DPIAs) under Article 35, breach noti

conducting-man-in-the-middle-attack-simulation: Simulates man-in-the-middle attacks using Ettercap, mitmproxy, and Bettercap

configuring-host-based-intrusion-detection: Configures host-based intrusion detection systems (HIDS) to monitor

configuring-microsegmentation-for-zero-trust: Configures microsegmentation policies to enforce least-privilege workload-to-workload

configuring-multi-factor-authentication-with-duo: Deploys Cisco Duo multi-factor authentication across enterprise applications,

containing-active-breach: Executes containment strategies to stop active adversary operations

convert-finder-skill-to-preprocessor-scripts: Convert an existing find-XXXX SKILL.md into a preprocessor Python script, updating configs/<GAMEVER>.yaml and removing the old SKILL.md. Covers xref-string-based and LLM_DECOMPILE-based discovery patterns.

cpp-testing: C++ testing workflow for unit and integration tests: GoogleTest/GoogleMock, CMake/CTest integration, diagnosing flaky tests, and running sanitizers and coverage for correctness signal. Use when writing or fixing C++ tests and test infrastructure.

cracking-technique: Auth/lab: password/hash recovery methodology; hash triage, candidate design, rules/masks, campaign evidence, audit-safe reporting.

create-pr: Create a GitHub pull request from staged task changes or an already-committed current branch. Deliver source/config/ reference changes together with their computed source-owned `bin_artifacts` closure. PR validation routing is owned by the default-branch trusted workflow; snapshots, gamedata, and ma

create-preprocessor-scripts: Create a new find-XXXX preprocessor Python script from scratch (no existing SKILL.md), add configs/<GAMEVER>.yaml skill and symbol entries. Covers xref-string-based and LLM_DECOMPILE-based discovery patterns. Use when a GitHub issue or user instruction specifies a new function to find.

ctf-methodology: CTF challenge triage and time management — identify the category and intended technique from the handout artifacts in the first 10 minutes, budget points vs. time, and know when to park a challenge. Load at the start of any CTF/jeopardy challenge, when handed an unknown file, URL, or "nc host port"

cve-search: Build evidence-backed CVE inventories and assess whether reported vulnerabilities match an asset's product, package, build, and configuration. Use for vulnerability lookup, asset review, and remediation prioritization.

cvss-scoring: Produces CVSS v4.0 vector strings from plain-text vulnerability descriptions by systematically evaluating base metrics. Use when scoring a vulnerability, generating a CVSS vector, or estimating severity.

deep-research-generic: Investigate a topic or compare options through in-depth, multi-source research. Use when a reliable answer needs several subquestions, competing explanations, or evidence beyond a quick lookup.

defense-threat-modeling: Threat-model a system or feature (STRIDE + attack trees) to find design-level risk before code. Load on "threat model", a new design/architecture review, security design questions, or planning controls. Signals: architecture diagram, data-flow, "what could go wrong", pre-build security.

deploying-osquery-for-endpoint-monitoring: Deploys and configures osquery for real-time endpoint monitoring using

design-before-implementation: Clarify and review designs before substantial changes. Use when requirements, interfaces, alternatives, or success criteria are unclear; skip a separate design phase for an already specified local fix.

detecting-anomalous-authentication-patterns: Detects anomalous authentication patterns using UEBA analytics, statistical

detecting-attacks-on-historian-servers: Detect cyber attacks on OT historian servers (OSIsoft PI, Ignition, GE

detecting-email-forwarding-rules-attack: Detect malicious inbox/mail-flow forwarding rules that adversaries create to maintain

detecting-insider-data-exfiltration-via-dlp: Detects insider data exfiltration by analyzing DLP policy violations,

detecting-insider-threat-behaviors: Detect insider threat behavioral indicators including unusual data access,

detecting-insider-threat-with-ueba: Implement User and Entity Behavior Analytics (UEBA) using Elasticsearch/OpenSearch

detecting-malicious-scheduled-tasks-with-sysmon: Detect malicious scheduled task creation and modification using Sysmon

detecting-modbus-protocol-anomalies: Detect anomalies in Modbus/TCP and Modbus RTU industrial traffic via function code monitoring, register range validation, timing analysis, and deep packet inspection, using Zeek's Modbus analyzer, Suricata IDS with OT rules, and Python Markov chain models of normal transaction sequences. Use for dep

detecting-process-hollowing-technique: Detect process hollowing (MITRE T1055.012) by analyzing memory-mapped

detecting-process-injection-in-memory: Detects process injection in a memory image by identifying private executable regions

detecting-rootkit-activity: Detects rootkit presence on compromised systems by identifying hidden

detecting-serverless-function-injection: Detects and prevents code injection attacks targeting serverless functions

detecting-spearphishing-with-email-gateway: Detect and block spearphishing emails that use personalized, researched

detecting-suspicious-powershell-execution: Hunt for suspicious PowerShell execution (T1059.001) such as encoded commands,

detecting-t1055-process-injection-with-sysmon: Detect process injection techniques (T1055) - including DLL injection, process

detecting-typosquatting-packages: Flag misspelled, brandjacked, and typosquatted package names across npm, PyPI, and crates.io before installation, using edit-distance, keyboard-proximity, and known-target corpus matching with typomania, Microsoft OSSGadget's oss-find-squats, and pypi-scan. Use before adding a new dependency, as a C

detecting-typosquatting-packages-in-npm-pypi: Detects typosquatting attacks in npm and PyPI package registries by

detecting-wmi-persistence: Detect WMI event subscription persistence (MITRE T1546.003) by analyzing Sysmon

diagram-generator: generate, refine, validate, and render diagrams from natural language, notes, code snippets, schemas, tables, or existing diagram source. use for flowcharts, swimlanes, sequence diagrams, state diagrams, er diagrams, class diagrams, architecture/c4-style diagrams, dependency graphs, gantt charts, mi

dimensional-analysis: Audits code for unit and decimal-scaling bugs and annotates it with dimensional comments recording the units of each value. Use when someone asks to audit or review code for unit confusion, decimals or scaling mismatches, WAD/RAY scale errors, or the wrong token's decimals; to annotate units in a co

dissecting-boot-and-kernel-rootkits: Analyzes bootkit and rootkit samples by identifying boot-process tampering (MBR/VBR/

emulating-shellcode-with-unicorn: Emulates position-independent shellcode in a controlled CPU emulator (Unicorn) to

evaluating-threat-intelligence-platforms: Evaluates and selects Threat Intelligence Platform (TIP) products based

executing-nist-rmf-authorization-to-operate: Drive a federal system through the NIST Risk Management Framework (SP 800-37 Rev 2) to an Authorization to Operate (ATO): Prepare, Categorize (FIPS 199), Select a control baseline (FIPS 200 / SP 800-53 Rev 5), Implement, Assess (SP 800-53A), Authorize, and Monitor continuously. Use when a system nee

executing-red-team-exercise: Run a stealthy, MITRE ATT&CK-mapped adversary emulation against an organization''s

external-feedback-triage: Evaluate external technical feedback before acting. Use for reviews, scanner findings, blog advice, model suggestions, and recommendations whose applicability or evidence is uncertain.

extracting-cobalt-strike-beacon-config: Extracts and interprets a Cobalt Strike Beacon configuration: decoding the

find-CNetworkGameServerBase_CreateFakeClient: Final-guarantee fallback for the find-CNetworkGameServerBase_CreateFakeClient preprocessor. Recovers CNetworkGameServerBase_CreateFakeClient in CS2 engine2.dll / libengine2.so when the string-xref preprocessor cannot resolve the function. Use this skill only after the deterministic preprocessor retu

find-CNetworkGameServerBase_ServiceQueue: Final-guarantee fallback for the find-CNetworkGameServerBase_ServiceQueue preprocessor. Recovers CNetworkGameServerBase_ServiceQueue in CS2 engine2.dll / libengine2.so when the LLM_DECOMPILE preprocessor cannot resolve the tail-call target of CNetworkGameServerBase_SpawnGroupThink. Use this skill on

find-CNetworkStringTableContainer_RemoveAllTables: Final-guarantee fallback for the find-CNetworkStringTableContainer_RemoveAllTables preprocessor. Recovers CNetworkStringTableContainer::RemoveAllTables in CS2 engine2.dll / libengine2.so by anchoring on its debug string and intersecting the hits with the CNetworkStringTableContainer vtable, so both

find-CServerSideClientBase_GetUserIDString: Final-guarantee fallback for CServerSideClientBase_GetUserIDString when its deterministic string-xref preprocessor cannot resolve the function. Locate the concrete user-ID formatting helper in engine2.dll / libengine2.so and write the semantic artifact for the active platform. Trigger: CServerSideCl

find-INetworkServerService_GetServerSerializersCRC: Final-guarantee fallback for the find-INetworkServerService_GetServerSerializersCRC preprocessor. Recovers INetworkServerService::GetServerSerializersMsg (legacy artifact key GetServerSerializersCRC, a virtual function of the CNetworkServerService vtable) in CS2 engine2.dll / libengine2.so by decomp

fix-cppheaders: Use when s2sdk C++ headers must be repaired to match the latest vtable or record-layout YAML references. Runs run_cpp_tests.py to obtain layout diffs, maps failing cpp_tests entries to their configured headers, edits only those headers, and repeats validation until the differences are resolved. Trig

gdpr-data-mapping: Build a GDPR-compliant data inventory — record of processing activities, lawful basis mapping, data subject rights readiness, and breach response procedures. Use for GDPR audits and privacy programs.

generate-reference-yaml: Generate reference YAML via project CLI into ida_preprocessor_scripts/references/<module>/<func_name>.<platform>.yaml

generating-capability-reports-with-capa: Uses capa to identify malware capabilities from a binary: running rule-based

generating-threat-intelligence-reports: Generates structured cyber threat intelligence reports at strategic,

get-func-from-yaml: Load function information from a pre-generated YAML file. Use this skill when you need function address, size, signature, and optional vtable metadata before downstream analysis. This skill checks for existing function YAML files and errors out if not found.

get-vtable-from-yaml: Load vtable information from a pre-generated YAML file. Use this skill when you need to get vtable address and size for a class before analyzing virtual functions. This skill checks for existing vtable YAML files and errors out if not found, ensuring the vtable analysis has been done first.

github-triage: Triages a repository's open GitHub issues and pull requests via the gh CLI. Optionally reviews and merges ready PRs — incrementally merging passing automated/bot PRs and maintainer-approved ones, and spawning review subagents for never-reviewed ones — then closes already-resolved issues with comment

golang-performance: Go performance workflow: benchmark and profile (pprof/trace), identify hotspots, reduce allocations/GC and contention, and verify improvements with repeatable measurement. Use only after you have evidence the Go code is the bottleneck.

handoff: Prepare or resume a transfer of work to another session, agent, or person. Use for explicit handoffs, including a fresh session in the same workspace or a readable handoff for a colleague, reviewer, or manager.

implementation-planning: Turn settled requirements into an executable plan. Use for work with dependencies, shared-file ownership, or a handoff; skip a separate plan for a straightforward local edit.

implementing-aes-encryption-for-data-at-rest: Guides implementing AES-256 encryption in GCM mode (FIPS 197) for files and data stores at rest, covering key derivation, IV/nonce management, and authenticated encryption. Use when deploying or configuring encryption for data at rest, establishing controls to meet compliance requirements, or review

implementing-bgp-security-with-rpki: Implement RPKI-based BGP route origin validation by creating Route Origin

implementing-cisa-zero-trust-maturity-model: Assess, gap-analyze, and progressively implement the CISA Zero Trust

implementing-conduit-security-for-ot-remote-access: Implements secure conduit architecture for OT remote access under the

implementing-continuous-security-validation-with-bas: Deploys Breach and Attack Simulation (BAS) platforms such as SafeBreach,

implementing-data-loss-prevention-with-microsoft-purview: Implements DLP policies using Microsoft Purview PowerShell cmdlets and

implementing-ddos-mitigation-with-cloudflare: Configure Cloudflare DDoS protection with managed rulesets, rate limiting,

implementing-delinea-secret-server-for-pam: Implements Delinea Secret Server for privileged access management,

implementing-device-posture-assessment-in-zero-trust: Implements device posture assessment as a zero trust access control

implementing-diamond-model-analysis: The Diamond Model of Intrusion Analysis provides a structured framework

implementing-digital-signatures-with-ed25519: Implements digital signatures using the Ed25519 algorithm (Curve25519), covering key-pair generation, signing, signature verification, and security tradeoffs versus RSA and ECDSA. Use when adding message or artifact signing and authentication-integrity checks to a system, or when advising on Ed25519

implementing-ebpf-security-monitoring: Implements eBPF-based security monitoring using Cilium Tetragon for

implementing-email-sandboxing-with-proofpoint: Email sandboxing detonates suspicious attachments and URLs in isolated

implementing-endpoint-dlp-controls: Implements endpoint Data Loss Prevention (DLP) controls to detect and

implementing-gdpr-data-subject-access-request: Automates GDPR Data Subject Access Request (DSAR) workflows including

implementing-iec-62443-security-zones: Designs security zones and conduits for industrial control systems

implementing-infrastructure-as-code-security-scanning: Implements automated security scanning for Infrastructure as Code using

implementing-iso-27001-information-security-management: Guides implementation of an ISO/IEC 27001:2022 Information Security Management System (ISMS) end to end: gap analysis and scoping, risk assessment methodology, Annex A control selection, Statement of Applicability (SoA) creation, and continuous improvement. Use when scoping a new ISMS, preparing for

implementing-just-in-time-access-provisioning: Implements Just-In-Time (JIT) access provisioning to eliminate standing privileges by granting temporary, time-bound access, covering approval workflows, automatic expiration/revocation, and PAM/IGA integration. Use when designing access approval workflows or replacing standing privileged accounts w

implementing-memory-protection-with-dep-aslr: Implements memory protection mechanisms including DEP (Data Execution

implementing-microsegmentation-with-guardicore: Implements microsegmentation with Akamai Guardicore Segmentation to map

implementing-mitre-attack-coverage-mapping: Implement MITRE ATT&CK coverage mapping to identify detection gaps, prioritize

implementing-nerc-cip-compliance-controls: Implements NERC CIP controls for Bulk Electric System (BES) cyber systems: asset

implementing-passwordless-authentication-with-fido2: Deploy FIDO2/WebAuthn passwordless authentication using security keys

implementing-pci-dss-compliance-controls: Implements PCI DSS 4.0.1's 12 requirements across 6 control objectives

implementing-policy-as-code-with-open-policy-agent: Implements policy-as-code enforcement with Open Policy Agent (OPA)

implementing-privileged-access-management-with-cyberark: Deploy CyberArk Privileged Access Management to discover, vault, rotate,

implementing-privileged-access-workstation: Design and implement Privileged Access Workstations (PAWs) using the

implementing-privileged-session-monitoring: Implements privileged session monitoring and recording using PAM

implementing-proofpoint-email-security-gateway: Deploy and configure Proofpoint Email Protection as a secure email gateway

implementing-rapid7-insightvm-for-scanning: Deploy and configure Rapid7 InsightVM Security Console and Scan Engines,

implementing-rsa-key-pair-management: Generates, stores, rotates, and manages RSA key pairs following NIST

implementing-runtime-application-self-protection: Deploy Runtime Application Self-Protection (RASP) agents to detect and

implementing-scim-provisioning-with-okta: Implement automated user lifecycle provisioning and deprovisioning using

implementing-secret-scanning-with-gitleaks: This skill covers implementing Gitleaks for detecting and preventing

implementing-secrets-management-with-vault: Deploy HashiCorp Vault for centralized secrets management, covering dynamic

implementing-security-chaos-engineering: Implements security chaos engineering experiments that deliberately

implementing-security-information-sharing-with-stix2: Create, validate, and share STIX 2.1 threat intelligence objects (indicators,

implementing-sigstore-for-software-signing: Implements Sigstore-based software signing and verification using Cosign

implementing-soar-automation-with-phantom: Implements Security Orchestration, Automation, and Response (SOAR) workflows

implementing-stix-taxii-feed-integration: Implements a STIX 2.1/TAXII 2.1 threat-intelligence feed consumer and

implementing-threat-intelligence-lifecycle-management: Build out a full CTI program around the six-phase threat intelligence

implementing-threat-modeling-with-mitre-attack: Implements threat modeling using the MITRE ATT&CK framework to map adversary

implementing-usb-device-control-policy: Implements USB device control policies to restrict unauthorized removable

implement-patch: Use when a confirmed local bug needs an invariant-level fix, variant search, tests, and one local commit.

interpreting-culture-index: Interprets Culture Index (CI) surveys, behavioral profiles, and personality assessment data. Supports individual profile interpretation, team composition analysis (gas/brake/glue), burnout detection, profile comparison, hiring profiles, manager coaching, interview transcript analysis for trait predi

investigating-insider-threat-indicators: Investigates insider threat indicators including data exfiltration attempts,

john: Auth/lab ref: CPU-based password cracker supporting hundreds of hash formats with wordlist, rules, and incremental modes.

known-problem-hint-research: Find a useful research lead when a technical task is stuck, unfamiliar, or has no clear next step. Use for unexplained errors, failed approaches, missing techniques, and uncertainty that docs, issues, papers, or prior work could resolve.

let-fate-decide: Draws the 12 Houses of the Zodiac Tarot spread to inject entropy into planning when prompts are vague, ambiguous, or casually delegated. Interprets the spread to guide next steps. Use when the user says 'let fate decide', 'YOLO', 'whatever', 'idk', or other nonchalant phrases, makes Yu-Gi-Oh referen

managing-intelligence-lifecycle: Manages the end-to-end cyber threat intelligence lifecycle from planning

managing-third-party-vendor-risk: Build and run a third-party/vendor risk management (TPRM) program aligned to NIST SP 800-161 C-SCRM: inventory and tier vendors, issue SIG/CAIQ questionnaires, review SOC 2/ISO 27001 evidence, set contractual right-to-audit clauses, monitor vendors continuously, and offboard securely. Use when asses

mapping-hunts-to-mitre-attack: Maps hunts and detections to MITRE ATT&CK for coverage analysis: tagging hypotheses

mapping-mitre-attack-techniques: Maps observed adversary behaviors, security alerts, and detection rules

memory-hygiene: Read, update, or design persistent agent memory. Use when deciding what may be stored, retrieving prior decisions, or resolving stale, conflicting, or incorrectly scoped notes.

modern-cpp: Guides C++ code toward modern idioms (C++20/23/26). Use when writing new C++ code, modernizing legacy patterns, or working on security-critical C++. Replaces raw pointers with smart pointers, SFINAE with concepts, printf with std::print, error codes with std::expected.

modern-python: Configures Python projects with modern tooling (uv, ruff, ty). Use when creating projects, writing standalone scripts, or migrating from pip/Poetry/mypy/black.

offensive-fast-checking:

offensive-initial-access:

offensive-keylogger-arch:

offensive-reporting: Penetration test and red team report writing methodology. Covers executive summary structuring (risk-led narrative for non-technical readers), technical finding format (title, severity, affected scope, narrative, reproduction steps, impact, remediation, references), CVSS v3.1 / v4.0 scoring with vec

opencode-agent-creator: Create, revise, or debug OpenCode agent definitions and teams: Markdown/JSON configuration, permissions, model routing, discovery, and native Task delegation.

opencode-plugin-creator: Create or revise OpenCode plugins: server entrypoints, hooks, custom tools, lifecycle, installation, and packaging.

open-sourcing: This skill should be used when the user asks to "open source this project", "prepare this repository for public release", "make this repo public", "check open-source readiness", "choose a license for this project", or "set up release automation" ahead of a public launch. Provides a release-readiness

orchestration: Choose and coordinate subagents, teams, or workflows: divide tasks, match models and effort, schedule dependencies, and integrate verified results. Use when deciding whether or how to delegate work.

panel-review: Reviews a code target by launching a panel of specialist auditor agents and merging their reports. Use when asked to run a panel review.

patching-bugs: Use when a known bug or falsifiable bug hypothesis in a local codebase needs a patch commit and reviewable proof report.

pci-dss-scoping: Scope a PCI DSS environment correctly — cardholder data flows, segmentation validation, and requirements mapping for compliance. Use when preparing for PCI DSS v4.0 assessments.

performing-access-recertification-with-saviynt: Configure and execute access recertification campaigns in Saviynt Enterprise

performing-access-review-and-certification: Designs and runs access review and certification campaigns-scoping,

performing-arp-spoofing-attack-simulation: Simulates ARP spoofing/cache-poisoning attacks in authorized lab or

performing-asset-criticality-scoring-for-vulns: Build a multi-factor asset criticality scoring model—incorporating data

performing-authenticated-scan-with-openvas: Configure and execute authenticated (credentialed) vulnerability scans using OpenVAS/Greenbone

performing-authenticated-vulnerability-scan: Plan and run authenticated (credentialed) vulnerability scans with scanners such as

performing-credential-access-with-lazagne: Extract stored credentials from compromised endpoints using the LaZagne

performing-cve-prioritization-with-kev-catalog: Fetch and parse the CISA Known Exploited Vulnerabilities (KEV) catalog,

performing-deception-technology-deployment: Deploys deception technology including honeypots, honeytokens, and decoy

performing-dmarc-policy-enforcement-rollout: Execute a phased DMARC rollout by inventorying sending sources, configuring

performing-entitlement-review-with-sailpoint-iiq: Runs entitlement review and access certification campaigns in SailPoint

performing-file-carving-with-foremost: Recovers files from disk images and unallocated space using Foremost's

performing-initial-access-with-evilginx3: Perform authorized initial access using EvilGinx3 adversary-in-the-middle

performing-insider-threat-investigation: Investigates insider threat incidents involving employees, contractors,

performing-lateral-movement-detection: Detects lateral movement techniques including Pass-the-Hash, PsExec,

performing-nist-csf-maturity-assessment: Conduct a NIST Cybersecurity Framework (CSF) 2.0 maturity assessment across the six core Functions (Govern, Identify, Protect, Detect, Respond, Recover), scoring organizational posture against the four Implementation Tiers (Partial, Risk-Informed, Repeatable, Adaptive) and producing an improvement r

performing-paste-site-monitoring-for-credentials: Monitor paste sites like Pastebin and GitHub Gists for leaked credentials,

performing-privacy-impact-assessment: Automates the Privacy Impact Assessment (PIA) workflow including data

performing-privileged-account-access-review: Conducts systematic reviews of privileged accounts to validate access

performing-privileged-account-discovery: Discovers and inventories privileged accounts across enterprise infrastructure,

performing-red-team-with-covenant: Conducts red team operations using the Covenant C2 framework for authorized

performing-s7comm-protocol-security-analysis: Perform security analysis of Siemens S7comm and S7CommPlus protocols

performing-sca-dependency-scanning-with-snyk: This skill covers implementing Software Composition Analysis (SCA) using

performing-threat-emulation-with-atomic-red-team: Executes Atomic Red Team tests for MITRE ATT&CK technique validation

performing-user-behavior-analytics: Performs User and Entity Behavior Analytics (UEBA) to detect anomalous

pr-improver: Runs an autonomous review-and-fix improvement loop over the current branch's changes until a PR review comes back clean, scoped mechanically to the directories the branch touched. Reviews are performed by an installed PR-review skill (default: pr-review-toolkit's review-pr). Use to fix review findin

processing-stix-taxii-feeds: Processes STIX 2.1 threat intelligence bundles delivered via TAXII 2.1

profiling-a-threat-actor-from-ttps: Profiles a threat actor by aggregating observed ATT&CK techniques into a TTP profile

profiling-threat-actor-groups: Develops comprehensive threat actor profiles for APT groups, criminal

prompt-engineering-patterns: Design and evaluate application prompts that extract, triage, or report evidence from security artifacts such as advisories, logs, source snippets, and scanner output.

prove-patch: Use when a local security patch commit needs independent scoped and three-arm proof.

python-testing: Python testing with pytest: fixtures, parametrization, mocking, test organization, async tests, Hypothesis, ExceptionGroup, free-threaded caveats, coverage, and CI hygiene. Use when writing or reviewing Python tests to improve correctness and reduce flakiness.

rea-analysis-optimization: Optimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.

rea-changelog-update: Prepare or rewrite REA release changelogs and GitHub release notes from pinned Git history, with verified contributor thanks and Release Please synchronization.

rea-ci-tests-audit: Audit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.

recovering-deleted-files-with-photorec: Recovers deleted files from disk images and storage media using PhotoRec's

rename-preprocessor-scripts: Rename a symbol (function, vfunc, vtable, struct member, global variable) across all preprocessor scripts, configs/<GAMEVER>.yaml entries, and tracked source-owned YAML artifacts. Use when a symbol's name changes (class rename, naming-convention fix, etc.), or when splitting a single finder into an

report-generation-technique: Assessment and bug-bounty reporting: executive summaries, single-finding submissions, CVSS, evidence chains, MITRE ATT&CK mapping, remediation, and review-ready structure.

reporting-bug-bounty-writeup: Turn a confirmed finding into a triage-friendly bug-bounty report (HackerOne/Bugcrowd) with correct severity and clean evidence. Load when a bug is validated and needs submitting, on "write the report", "CVSS", "severity", or before disclosure. Signals: a reproduced finding, a program's VRT/severity

reporting-cvss-scoring: Assign a defensible severity to a finding — build the CVSS 3.1 vector from demonstrated impact and reconcile it with the program's own scale. Load on "what severity", "CVSS", "rate this bug", or before submitting a report. Signals: a confirmed finding needing a score, a program VRT/severity policy,

reporting-evidence-review: Pre-handoff audit of an engagement package — scope confirmed, every finding traceable to reproducible evidence, activity-log leads closed with rationale, artifact hashes intact. Load before writing the final report or handing a case to a teammate/client, on "is this ready to report", "review my enga

reporting-pentest-report: Structure a professional penetration-test report (engagement deliverable, not a single bug). Load at the end of a pentest, on "write the pentest report", "executive summary", "deliverable", or compiling findings for a client. Signals: engagement wrap-up, multiple findings, client report.

reporting-triage-communication: Work productively with triagers after you submit — answer follow-ups, and handle duplicate, not-applicable, or severity disputes professionally. Load on "triage asked for more info", "they closed it as N/A", "dispute the severity/duplicate", or managing a report thread. Signals: a submitted report a

reporting-triage-validation: Validate a finding BEFORE you write it up — kill false positives, confirm real impact, check scope, and deduplicate. Load after a candidate bug and before reporting-bug-bounty-writeup or reporting-pentest-report. Signals: "I think I found", "is this reportable", a scanner hit, a reflected value, a 5

resolve-pr-conflict: Resolve an open same-repository GitHub PR conflict by merging its base into the writable dev head, resolving source, config, and `s2sdk` gitlink intent semantically, rebuilding only the conflicted source-owned `bin_artifacts` via targeted isolated runs, running the repository review/format/test gate

review-walkthrough: Generates an interactive HTML walkthrough for reviewing code changes. Use only when explicitly called.

rust-review: Performs comprehensive Rust security review for safe/unsafe boundary issues, memory safety in unsafe blocks, concurrency hazards, panic-induced DoS, FFI safety, and async runtime mistakes. Use when auditing Rust crates, services, or libraries — particularly those with `unsafe`, FFI, or concurrent co

securing-github-actions-workflows: Hardens GitHub Actions workflows against supply chain attacks, credential

shellcode-dev: Auth/lab dev: shellcode-format engineering; PIC, ABI, syscalls, encoders, memory permissions, reflective-loader labs, emulator validation.

skill:

skill-app-creator: Create or evolve skill-apps: Agent Skills with executable workflows and consistent deliverables. Use when turning a recurring task into a skill with deterministic helpers, output contracts, runtime diagnostics, or resumable sessions.

skill-creator: Create, revise, evaluate, or package Agent Skills. Use for SKILL.md instructions, activation descriptions, and bundled resources.

skill-template: One to three sentences describing what this skill does and the conditions

sleep-masking-dev: Auth/lab dev: sleep-state research; timers/APC/waitable timers, memory-at-rest, permission transitions, key lifecycle, reliability checks.

slicing-code-context: Selects bounded, graph-informed source slices with Trailmark and delegates focused code analysis or patch-proposal work to a smaller subagent. Use when offloading function-, class-, caller-, callee-, call-path-, entrypoint-, or line-focused code tasks to constrained or locally hosted models without

soc2-readiness: Prepare an organization for a SOC 2 Type I or II audit — trust services criteria mapping, evidence collection, control implementation, and remediation planning. Use when starting a SOC 2 journey or preparing for an audit window.

software-architecture: Design, evolve, and review software architecture, from small tools and libraries to multi-service systems. Use for module boundaries, domain models, public contracts, data ownership, quality trade-offs, architectural refactoring, and behavior-preserving simplification.

spec-to-code-compliance: Check code against the documentation that specifies it - which requirements hold, which the code contradicts, which are absent, and what the code does that no document mentions. Use when comparing an implementation against a whitepaper, protocol spec, or design document.

state-diff: Compare two state snapshots to identify register and memory changes between two points in time

supply-chain-risk-auditor: Audits a project's dependencies for supply-chain risk: version-matched advisories for direct dependencies and the full lockfile tree, abandoned or archived upstreams, npm publisher concentration, and install-time script execution. Use when asked to audit dependencies, assess supply-chain or third-pa

testing-handbook-generator: Generates Claude Code skills from the Trail of Bits Testing Handbook (appsec.guide), analyzing handbook pages and emitting SKILL.md files with the structure each skill type requires. Use when creating or refreshing a skill from handbook content, or when the user names the testing handbook or appsec.

testing-reliability: Diagnose flaky tests, misleading mocks or fakes, sleep-based waits, brittle fixtures, test-only production hooks, weak assertions, and mutation-testing gaps. Use when CI behavior differs, tests hide defects, or coverage creates false confidence.

titus: Scan local files and Git history for secrets with Titus and review its datastore.

tracking-adversary-infrastructure: Tracks adversary C2 and staging infrastructure by clustering indicators on shared

tracking-threat-actor-infrastructure: Discovers and maps adversary-controlled infrastructure (C2 servers,

trailmark-finding-triage: Performs graph-assisted triage of a single security finding, SARIF result, weAudit annotation, suspicious function, or report excerpt using Trailmark reachability, entrypoint paths, taint, privilege-boundary, blast-radius, caller/callee, and neighborhood evidence. Use when deciding whether one candi

trailmark-summary: Runs a Trailmark summary analysis on a codebase. Returns auto-detected languages, entry point count, and dependency list. Use when vivisect or galvanize needs a quick structural overview. Triggers: trailmark summary, code summary, structural overview.

tuning-detections-to-reduce-false-positives: Tunes noisy detections by analyzing historical alert data to quantify false-positive

validate-bug: Use when a bug PoC package needs an independent rerun and judgment before patching.

validating-detections-with-atomic-tests: Validates detection coverage by mapping Atomic Red Team tests to ATT&CK techniques,

validating-tpm-measured-boot-attestation: Verifies TPM 2.0 measured-boot integrity and remote attestation with

verification-before-completion: Check evidence before reporting work complete, fixed, passing, or ready. Use at a completion boundary or when later changes may have invalidated an earlier result.

verifying-build-provenance-with-slsa-sigstore: Verifies artifact signatures and SLSA provenance using Sigstore's

vulnerability-triage-brocards: This skill should be used when the user asks to "triage a vulnerability report", "assess a CVE", "evaluate a bug bounty submission", "decide if a finding is valid", "review a security finding", "dismiss a vulnerability", "should we fix this CVE", "prioritize a vulnerability report", or needs to dete

writing-lean-proofs: Writes and reviews structured Lean 4 proofs and designs Lean libraries following Mathlib conventions. Use when proving theorems in Lean, formalizing mathematics or specifications in Lean 4, defining new types or definitions in a Lean library, reviewing Lean proofs for readability and maintainability

zeroize-audit: Detects missing zeroization of sensitive data in source code and identifies zeroization removed by compiler optimizations, with assembly-level analysis, and control-flow verification. Use for auditing C/C++/Rust code handling secrets, keys, passwords, or other sensitive data.

Canonical: https://notholy.com/pt-br/skills/category/compliance-reporting
