Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    FirmGraph Firmware Checks Demo.

    1

    Run a local FirmGraph demo to detect and verify firmware configuration vulnerabilities and hardcoded secrets.

    Free

    Security scanned
    FirmGraph Firmware Checks Demo.

    FirmGraph Firmware Checks Demo.

    Example session with this skill installed

    Run the FirmGraph demo in ./demo-work and ./demo-out to show me how it detects hardcoded secrets in firmware configurations.

    • Read your context and instructions
    • Compiled the firmgraph firmware checks
    • Generated the document

    The FirmGraph ChecksEngine has successfully processed the synthetic fixtures. The initial scan identified five security violations, which were subsequently remediated and verified in the second pass.

    FirmGraph Demo Security Findings

    Finding IDSeverityCategoryEvidence (Redacted)Status
    FG-SEC-001CriticalHardcoded Key[REDACTED_HASH:8f3e...]Fixed
    FG-SEC-002CriticalHardcoded Password[REDACTED_HASH:a1b2...]Fixed
    FG-SET-001HighInsecure Protocoltelnet=enabledFixed
    FG-SET-002HighRoot Loginpermit_root_login=yesFixed
    FG-SET-003HighWeak Encryptioncipher=desFixed

    Execution Manifest Summary

    • Engine Version: 8bde16f
    • Baseline Findings: 5
    • Verification Findings: 0
    • Artifacts: Generated report.md, findings.json, and manifest.json in ./demo-out.

    Changes Applied for Verification

    1. Replaced the RSA private key header with a reference to a secure keystore.
    2. Updated the configuration fixture to disable Telnet and permit only SSH with public-key authentication.
    3. Upgraded the cipher suite from DES to AES-256-GCM.

    Next steps

    1. Open ./demo-out/report.html in your browser to view the formatted evidence.
    2. Review the manifest.json file for the full SHA-256 audit trail of the fixtures.
    3. Compare the before and after fixtures in the workspace to see the specific remediation patterns.

    report.html

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Manual firmware audits are slow and prone to missing hardcoded secrets or insecure configurations. This skill provides a controlled environment to run the open-source FirmGraph ChecksEngine against synthetic fixtures, demonstrating how automated pattern matching identifies vulnerabilities in firmware files.

    What it does

    • Environment setup initializes a pinned version of the FirmGraph engine and a dedicated virtual environment.
    • Pattern detection identifies five specific security findings including hardcoded secrets and insecure configurations.
    • Remediation verification generates a corrected fixture and reruns checks to confirm a zero-finding state.
    • Evidence generation produces JSON findings, SHA-256 hashes, and local HTML/Markdown reports.
    • Redaction management handles sensitive evidence strings using hashing and placeholder values.

    How it works

    1. System Check: Runs the doctor command to verify Python 3.12+, Git, and uv are available.
    2. Engine Setup: Downloads and installs the FirmGraph engine at a specific commit into a local workspace.
    3. Demo Execution: Processes synthetic fixtures to produce five baseline security findings.
    4. Verification: Applies configuration changes and verifies the remediated files pass all checks.

    Frameworks & tools

    This skill uses Python 3.12, the FirmGraph ChecksEngine, and uv for package management. It operates entirely on the local filesystem and requires terminal access.

    Why this beats prompting it yourself

    Prompting an LLM to "find bugs" often results in hallucinations or missed edge cases in configuration files. This skill executes a specific, deterministic engine that uses formal rules to ensure reproducible results and verifiable evidence.

    Use cases

    • Tool evaluation by testing FirmGraph's detection logic before integration.
    • Security training to show developers how hardcoded secrets appear in firmware.
    • Pipeline prototyping for automated firmware configuration checking.

    Known limitations

    Does not perform binary analysis, CVE matching, or SBOM creation. Tested on macOS; Windows is not supported. Requires a local terminal and Python 3.12.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Security.

    Requires Python 3.12+ and terminal access. Does not perform binary analysis, CVE matching, or SBOM creation. Tested on macOS; Windows is not supported.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 9 days ago

    • Free with an Agensi account

    Software
    Python

    Permissions

    Terminal / Shell
    Read Files
    Write Files
    Network Access
    Listed9 days ago

    What's inside

    Frequently Asked Questions

    This skill provides a pre-configured local environment to run the FirmGraph ChecksEngine, allowing you to test automated detection of hardcoded secrets and insecure configurations using synthetic firmware fixtures. It solves the issue of manual audit fatigue and LLM hallucinations by providing deterministic, rule-based security findings.

    The skill requires a local machine running macOS with Python 3.12+, Git, and the `uv` package manager installed. It is designed to work with AI agents that have terminal access and local filesystem permissions to execute Python scripts.

    No, this demo focuses specifically on pattern matching for configuration vulnerabilities and hardcoded credentials. It does not perform binary analysis, CVE lookups, or generate Software Bill of Materials (SBOM) reports.

    You receive the complete orchestration logic to set up the FirmGraph engine, a suite of synthetic test fixtures, a remediation verification workflow, and automated reporting templates for JSON, HTML, and Markdown.

    The skill uses the `doctor` command to verify your local environment and installs a specific, pinned commit of the open-source FirmGraph engine. This ensures that the demo remains stable and reproducible even if the main engine repository changes.

    Absolutely. The skill is designed to generate evidence in JSON and Markdown formats, making it an ideal prototype for developers looking to integrate FirmGraph's automated checks into a CI/CD pipeline.

    New in Security

    Free