Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Docker Security Linter: Zero-Dependency DevSecOps Scanner

    1

    A zero-dependency static analysis tool for Docker and Compose files to detect misconfigurations and secret leaks.

    $6.99

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Docker Security Linter: Zero-Dependency DevSecOps Scanner

    Docker Security Linter: Zero-Dependency DevSecOps Scanner

    Example session with this skill installed

    FROM node:latest

    ENV STRIPE_SECRET_KEY="sk_live_51Mxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
    ENV DB_PASS="admin123"

    RUN apt-get update && apt-get install -y curl

    RUN curl -sL https://deb.nodesource.com/setup_18.x | bash -

    ADD http://example.com/legacy-binary.tar.gz /app/legacy-binary.tar.gz

    WORKDIR /app
    COPY . .
    RUN npm install

    CMD ["npm", "start"]

    • Read your context and instructions
    • Compiled the docker security linter

    I ran the linter's Dockerfile checks against your file by hand (no code was executed). It fails with 6 findings.

    {
      "status": "failed",
      "files_scanned": 1,
      "vulnerabilities": [
        {
          "file": "Dockerfile",
          "line": 1,
          "type": "Mutable Base Image",
          "severity": "Medium",
          "message": "Base image 'node:latest' is unpinned. Pin a specific version or digest."
        },
        {
          "file": "Dockerfile",
          "line": 3,
          "type": "Hardcoded Secret",
          "severity": "Critical",
          "message": "Found literal value for STRIPE_SECRET_KEY: 'sk_l********'"
        },
        {
          "file": "Dockerfile",
          "line": 4,
          "type": "Hardcoded Secret",
          "severity": "Critical",
          "message": "Found literal value for DB_PASS: 'admi********'"
        },
        {
          "file": "Dockerfile",
          "line": 8,
          "type": "Arbitrary Code Execution",
          "severity": "High",
          "message": "RUN pipes curl directly into bash. Download, verify a checksum, then execute."
        },
        {
          "file": "Dockerfile",
          "line": 10,
          "type": "Insecure Remote Fetch",
          "severity": "High",
          "message": "ADD fetches a remote plain-HTTP URL with no checksum verification."
        },
        {
          "file": "Dockerfile",
          "line": 16,
          "type": "Missing USER directive",
          "severity": "High",
          "message": "Container runs as root. Define a non-root USER."
        }
      ]
    }
    

    What to fix first

    Rotate the Stripe key now. A sk_live_ key in an ENV line is baked into the image layers and history, and in your git history if this file was committed. Removing it from the Dockerfile is not enough. Also change the DB password.
    2.

    Pass secrets at runtime. Use docker run --env-file, Compose ${VAR} pass-throughs, or Docker/BuildKit secrets (RUN --mount=type=secret,...) instead of ENV/ARG.
    3.

    Pin the base image, e.g. FROM node:18-slim (or a digest). Since you install Node 18 via NodeSource anyway, using the node:18 image makes lines 6-8 unnecessary.
    4.

    Replace curl | bash. If you keep the NodeSource setup, download the script, check its checksum or GPG signature, then run it. The simpler fix is to drop it, as above.
    5. Replace the ADD http:// line. Use HTTPS with curl -fsSLO, then sha256sum -c, then extract.
    6.

    Add a non-root user before CMD, e.g. USER node (the official Node images include it). Use COPY --chown=node:node . . so the files stay readable.

    I can write a hardened version of the Dockerfile if you'd like.

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

    About this skill

    Shipping insecure containers is a liability. This skill provides a zero-dependency, static analysis tool for Docker environments to catch misconfigurations and credential leaks before they reach production. It analyzes files without requiring a running Docker daemon, making it ideal for pre-build validation.

    What it does

    • Image validation scans for mutable base tags and missing non-root USER directives to prevent breakout risks.
    • Secret detection identifies hardcoded credentials in ENV or ARG layers while masking values for privacy.
    • Compose auditing flags dangerous capabilities like privileged mode, host network binding, and Docker socket mounts.
    • Execution safety detects risky patterns like piping unverified remote scripts directly into a shell.
    • CI/CD ready output generates structured JSON reports for automated pass/fail gate integration.

    How it works

    1. Targeting specifies the path to your Dockerfile or docker-compose.yml for analysis.
    2. Static scan executes a non-runtime audit of the file structure and directives.
    3. Fingerprinting identifies potential secrets and masks them to prevent further exposure.
    4. Reporting returns a machine-readable JSON object detailing severity levels and line numbers for every finding.

    Frameworks & tools

    Built for Node 18+ environments. It operates as a standalone linter requiring no external packages or Docker engine access.

    Why this beats prompting it yourself

    Generic prompts often miss subtle permission escalations like specific kernel capabilities or host socket mounts. This skill uses a defined security specification to ensure consistent, repeatable audits that won't hallucinate non-existent security rules or leak your actual secrets in the logs.

    Use cases

    • Auditing legacy Dockerfiles before migrating to a new container registry.
    • Validating docker-compose files in local development to prevent accidental open port publishing.
    • Adding a security gate to GitHub Actions or GitLab CI pipelines.
    • Reviewing third-party container configurations before deployment.

    Known limitations

    Requires Node 18 or higher to run. Does not validate runtime behavior or dynamic environment variables that are not explicitly defined as literals in the files.

    Requires Node 18+. Static analysis only; cannot detect vulnerabilities in dynamic environment variables or running container states.

    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 any payment.

    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

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 8 days ago

    Requires

    Malicious

    Permissions

    Terminal / Shell
    Read Files
    Network Access
    Write Files

    Allowed Hosts

    malicious.com
    Listed8 days ago

    What's inside

    Frequently Asked Questions

    Unlike manual checks or generic prompts, this linter uses a strict security specification to identify specific vulnerabilities like missing non-root USER directives, privileged mode, and hardcoded secrets without risking 'hallucinations' or missed edge cases.

    No, this is a static analysis tool that audits the text of your Dockerfiles and Compose files directly, meaning you can run it in isolated environments without needing a Docker engine or daemon installed.

    The tool detects hardcoded credentials in ENV and ARG directives, but it includes an automatic masking feature that hides the actual values in the output report to ensure your secrets remain private.

    This skill requires a Node 18+ environment and is designed to integrate seamlessly into AI agent workflows or CI/CD pipelines (like GitHub Actions) that support structured JSON output.

    The linter focuses on static file structure; it will catch hardcoded values but cannot validate dynamic variables injected at runtime or analyze the behavior of the container once it is actually running.

    New in Code Quality & Review