Back to skill

Security audit

UI/UX Design and Development

Security checks for vulnerabilities and agentic risk

Overview

The skill is a coherent UI-design helper, but its setup makes privileged, persistent Nginx changes and can expose generated files over the network.

Review before installing. Prefer running generated previews in an unprivileged local dev server or isolated environment. Do not run setup.sh with sudo on a workstation or shared host unless you accept persistent Nginx changes and possible network exposure; if used, bind to localhost, validate the port and serve directory, and remove the Nginx site when finished.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (4)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/setup.sh:5
Finding

Unvalidated Arguments Permit Privileged Nginx Configuration Injection and Arbitrary Directory Ownership Changes

Content
View full analysis
/dev/null << NGINX server { listen $PORT; server_name _; root $SERVE_DIR; index index.html; location / { try_files \$uri \$uri/ \$uri/index.html =404; } # Cache static assets location ~* \.(css|js|png|jpg|gif|svg|ico|woff2?)$ { expires 1h; add_header Cache-Control "public, immutable"; } } NGINX ``` ### Technical Analysis The script accepts `PORT` and `SERVE_DIR` directly from positional command-line arguments without validating their format or constraining their values. Both values are interpolated into an Nginx configuration that is written to `/etc/nginx` through `sudo`. Shell quoting does not protect the generated Nginx configuration: embedded newline characters or Nginx syntax remain intact when the values are expanded inside the heredoc. A crafted value can therefore introduce additional Nginx directives or alter the intended configuration structure. The directory argument is also passed to privileged `mkdir` and `chown` operations. It is not canonicalized or restricted to an approved serving root. If an existing sensitive directory is supplied, the script attempts to transfer its ownership to the invoking user. Although the `chown` operation is not recursive, changing the ownership of a sensitive directory can allow subsequent unauthorized modifications to files, configuration, or directory entries. ### Attack Path 1. An attacker or ...[truncated 1283 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/setup.sh:45
Finding

Generated Content Is Persistently Exposed on All Network Interfaces Without Authentication

Content
View full analysis
/dev/null << NGINX server { listen $PORT; server_name _; root $SERVE_DIR; index index.html; location / { try_files \$uri \$uri/ \$uri/index.html =404; } # Cache static assets location ~* \.(css|js|png|jpg|gif|svg|ico|woff2?)$ { expires 1h; add_header Cache-Control "public, immutable"; } } NGINX # Enable site sudo ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/ui-designer # Test and reload nginx sudo nginx -t && sudo systemctl reload nginx ``` ### Technical Analysis The generated Nginx server uses `listen $PORT` without an explicit loopback address. Under normal Nginx behavior, this binds the service to all available interfaces for the selected port. The wildcard `server_name _` accepts requests regardless of the supplied host name. No authentication, client-address restriction, TLS configuration, or access-control layer is configured. The site is also enabled persistently through `/etc/nginx/sites-enabled`, and no teardown procedure is included. Consequently, all content stored under the serving directory may remain accessible to network peers after the immediate design session ends. This behavior is particularly sensitive because the Skill is intended to process draft designs and user-provided media assets, which users may reasonably assume are local previews. ### Attack Path 1. The user runs the documented setup procedure. 2. The script creates and enables an Nginx virtual host bound to the selected port on all interfaces. 3. The Skill writes generated pages and user-provided assets beneath the configured document root. 4. A network peer discovers or knows the host and port. 5. Th ...[truncated 616 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Error
Location
scripts/screenshot.sh:11
Finding

Headless Chromium Executes Page JavaScript with the Browser Sandbox Disabled

Content
View full analysis
/dev/null ``` ### Technical Analysis The screenshot helper launches Chromium with `--no-sandbox`. This disables Chromium's process sandbox while the browser parses HTML and executes JavaScript from the supplied URL and any third-party resources loaded by that page. The URL parameter is correctly quoted, so there is no demonstrated shell command injection at this location. The security issue instead concerns browser containment: generated pages can contain user-controlled code, remote resources, or compromised CDN content. If such content exploits a Chromium vulnerability, disabling the sandbox removes an important defense that would otherwise limit access to the host. The script does not restrict URLs to a trusted local origin. It can therefore be directed to arbitrary local or remote pages, including pages designed specifically to attack headless browsers. ### Attack Path 1. An attacker causes the screenshot workflow to open an attacker-controlled page or a generated page containing attacker-controlled JavaScript. 2. The page executes in headless Chromium and may load additional remote content. 3. Malicious content exploits a browser rendering or JavaScript-engine vulnerability. 4. Because Chromium was launched with `--no-sandbox`, the exploit operates without the normal browser sandbox boundary. 5. The resulting process can access resources available to the operating-system account running the script. This attack requires a suitable browser vulnerability or equivalent browser compromise; `--no-sandbox` does not by itself execute operating-system command ...[truncated 569 chars]
Remediation
View remediation

T08 · Insecure Dependencies

Warning
Location
SKILL.md:31
Finding

Generated Pages Load Mutable Third-Party JavaScript Without Integrity Verification

Content
View full analysis
``` ### Technical Analysis The prescribed page template executes JavaScript directly from public content-delivery networks whenever a generated page is opened. The Tailwind URL is unversioned, while the React URLs select a major-version range rather than an exact immutable release. The Babel URL is also unversioned. None of the script elements includes a Subresource Integrity hash. The generated page therefore cannot verify that the fetched content is the exact code reviewed or expected when the page was created. This creates a supply-chain trust boundary at runtime. A CDN compromise, package-account compromise, malicious upstream release, or unexpected upstream change could alter the JavaScript executed by every generated page. The same scripts are also executed during screenshot review, where Chromium is launched without a sandbox. ### Attack Path 1. The Skill generates a page using the documented template. 2. A user or the screenshot workflow opens the page. 3. The browser requests the referenced scripts from the public CDNs. 4. An upstream package, CDN response, or mutable version target supplies modified JavaScript. 5. Because no integrity hash is present, the browser accepts and executes the modified response. 6. The script runs in the generated page's origin and can read or alter page content and make network requests permitted by the browser environment. ### Impact Assessment Compromised dependency code can manipulate generated UI content, captur ...[truncated 418 chars]
Remediation
View remediation
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (16)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding

The skill is presented as a natural-language UI generator, but it also invokes screenshot tooling against URL inputs and writes output to filesystem paths. In context, this expands the skill into headless browsing/URL-fetch territory, which is more dangerous because arbitrary URL handling can enable internal network access, local service interaction, or unexpected data capture if not tightly restricted.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill is presented as a natural-language UI generator, but it also invokes screenshot tooling against URL inputs and writes output to filesystem paths. In context, this expands the skill into headless browsing/URL-fetch territory, which is more dangerous because arbitrary URL handling can enable internal network access, local service interaction, or unexpected data capture if not tightly restricted.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

High
Category
Not specified by scanner
Confidence
98% confidence
Finding

The manifest describes a skill for generating and serving live web UI designs from natural-language prompts, but this script performs standalone image format conversion to WebP. That behavior is not an obvious implementation detail of HTML/CSS/JS UI generation or serving, making the file's actual function materially different from the declared skill purpose.

Content

No source excerpt is available for this finding.

Chaining Abuse

High
Category
Tool Misuse
Confidence
75% confidence
Finding

Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Content

Scanner excerpt · scripts/setup.sh (reported line 73)May include surrounding context.

sh
sudo ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/ui-designer

# Test and reload nginx
sudo nginx -t && sudo systemctl reload nginx

echo ""
echo "=== Setup Complete ==="

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
94% confidence
Finding

The skill directs the agent to execute shell commands (setup.sh, screenshot.sh, convert-image.sh, zip) but does not declare any tool scope or allowed-tools restrictions. That creates an authorization gap where a seemingly design-focused skill can invoke powerful local execution paths, increasing the chance of misuse or unsafe command execution in environments that rely on manifest scoping for containment.

Content

No source excerpt is available for this finding.

Vague Triggers

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The trigger text is broad enough to match many generic requests to design, create, build, prototype, update, or tweak webpages. Over-broad activation is dangerous because it can cause this shell-capable skill to run in situations where a simpler, lower-privilege response would suffice, unnecessarily exposing file and command-execution functionality.

Content

No source excerpt is available for this finding.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
90% confidence
Finding

Using sudo to create a system directory is not inherently malicious, but in this skill it grants elevated permissions to an automation path that users may treat as routine. If parameters are misused or the environment is sensitive, this can create or alter privileged filesystem locations unexpectedly.

Content

Scanner excerpt · scripts/setup.sh (reported line 14)May include surrounding context.

sh
echo "Serve directory: $SERVE_DIR"

# Create serve directory
sudo mkdir -p "$SERVE_DIR"
sudo chown "$(whoami):$(whoami)" "$SERVE_DIR"
chmod 755 "$SERVE_DIR"

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The setup script goes beyond generating UI files and performs privileged host-level web server provisioning by creating system directories, changing ownership, and later integrating with Nginx. In the context of an agent skill, this expands the trust boundary and can unexpectedly modify the host system, increasing risk if the script is run on a developer workstation or shared environment.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The script performs privileged filesystem changes immediately, without confirming the target path or warning that it will alter host-owned web-serving locations. That is dangerous because users may execute it expecting harmless setup for a design tool, while it actually makes persistent system changes requiring elevated privileges.

Content

No source excerpt is available for this finding.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
89% confidence
Finding

The script uses sudo to chown the serve directory to the invoking user, which changes ownership of a filesystem path under a configurable location. If a dangerous or unintended path is supplied, this could alter permissions on sensitive directories and weaken system integrity.

Content

Scanner excerpt · scripts/setup.sh (reported line 15)May include surrounding context.

sh
# Create serve directory
sudo mkdir -p "$SERVE_DIR"
sudo chown "$(whoami):$(whoami)" "$SERVE_DIR"
chmod 755 "$SERVE_DIR"

# Create welcome page

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
80% confidence
Finding

Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Content

Scanner excerpt · scripts/setup.sh (reported line 16)May include surrounding context.

sh
# Create serve directory
sudo mkdir -p "$SERVE_DIR"
sudo chown "$(whoami):$(whoami)" "$SERVE_DIR"
chmod 755 "$SERVE_DIR"

# Create welcome page
cat > "$SERVE_DIR/index.html" << 'WELCOME'

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The script unconditionally writes index.html into the serve directory and later overwrites the Nginx site configuration path via tee, potentially replacing existing content or prior configuration for the same site name. Silent overwrites can cause loss of existing files, service misconfiguration, or unintended exposure of content.

Content

No source excerpt is available for this finding.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
94% confidence
Finding

Writing directly to /etc/nginx/sites-available via sudo tee modifies core web-server configuration with root privileges. In a skill whose purpose is UI generation, this is more dangerous because it couples content generation with privileged infrastructure changes that can break or expose the host web server.

Content

Scanner excerpt · scripts/setup.sh (reported line 50)May include surrounding context.

sh
# Configure Nginx
NGINX_CONF="/etc/nginx/sites-available/ui-designer"
sudo tee "$NGINX_CONF" > /dev/null << NGINX
server {
    listen $PORT;
    server_name _;

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
91% confidence
Finding

Creating a symlink in /etc/nginx/sites-enabled with sudo enables the site immediately at the system level. This can unintentionally publish generated content or conflict with existing Nginx site management on the host.

Content

Scanner excerpt · scripts/setup.sh (reported line 70)May include surrounding context.

sh
NGINX

# Enable site
sudo ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/ui-designer

# Test and reload nginx
sudo nginx -t && sudo systemctl reload nginx

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
90% confidence
Finding

Running nginx -t and reloading the service with sudo applies configuration changes to the live web server. Even with syntax testing, this can disrupt service availability or activate unintended exposure of files if the configuration or root path is wrong.

Content

Scanner excerpt · scripts/setup.sh (reported line 73)May include surrounding context.

sh
sudo ln -sf "$NGINX_CONF" /etc/nginx/sites-enabled/ui-designer

# Test and reload nginx
sudo nginx -t && sudo systemctl reload nginx

echo ""
echo "=== Setup Complete ==="

Natural-Language Policy Violations

Low
Category
Not specified by scanner
Confidence
86% confidence
Finding

The provided HTML template hard-codes <html lang="en">, which imposes English as the page language by default. The file does not instruct the agent to ask the user for language preference or explain that the skill is intentionally English-only for a justified region-specific use case.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.