Back to skill

Security audit

AccessMind

Security checks for vulnerabilities and agentic risk

Overview

This accessibility-audit skill is mostly related to its stated purpose, but it needs Review because it uses broad browser permissions and unsafe audit tooling that could expose page content or weaken browser protections.

Install only in a disposable browser profile or isolated test environment, and audit only sites you are authorized to test. Be aware that the extension can run on every site you visit, screenshots may be sent to local services on fixed ports, and some scripts weaken browser isolation or execute mutable third-party tooling. Avoid using this with banking, admin, intranet, production, or sensitive authenticated pages until permissions, dependency pinning, sandbox flags, and HTML rendering are fixed.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
Findings (8)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/full-audit.sh:199
Finding
Arbitrary JavaScript Execution Through Output Directory Injection<![CDATA[ ## Vulnerability Details **File Location**: `scripts/full-audit.sh:199-225` and `scripts/full-audit.sh:248-257` **Vulnerability Type**: User-controlled data interpolated into executable JavaScript source **Risk Level**: High ### Vulnerable Code ```bash local report="$OUTPUT_DIR/full-audit-report-$TIMESTAMP.md" if [ -f "$OUTPUT_DIR/axe-full-$TIMESTAMP.json" ]; then echo "### Axe-core Bulguları" >> "$report" echo "" >> "$report" node -e " const fs = require('fs'); try { const data = JSON.parse(fs.readFileSync('$OUTPUT_DIR/axe-full-$TIMESTAMP.json', 'utf8')); const violations = data.violations || []; const incomplete = data.incomplete || []; const passes = data.passes || []; console.log('| Kategori | Sayı |'); console.log('|----------|------|'); console.log('| İhlaller | ' + violations.length + ' |'); console.log('| İncelenecek | ' + incomplete.length + ' |'); console.log('| Geçen | ' + passes.length + ' |'); console.log(''); if (violations.length > 0) { console.log('### İhlal Detayları'); console.log(''); violations.forEach(v => { console.log('#### ' + v.id); console.log(''); console.log('- **Etki:** ' + v.impact); console.log('- **Açıklama:** ' + v.description); console.log('- **Yardım:** ' + v.helpUrl); console.log('- **Etkilenen Element:** ' + v.nodes.length); console.log(''); }); } } catch (e) { console.log('Sonuçlar işlenemedi'); } " >> "$report" 2>/dev/null || echo "Sonuçlar işlenemedi" >> "$report" fi ``` The same construction is used for the Lighthouse report: ```bash node -e " const fs = require('fs'); try ...[truncated 1668 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Never interpolate user-controlled paths into source passed to `node -e`. - Pass paths as positional arguments: ```bash node - "$OUTPUT_DIR/axe-full-$TIMESTAMP.json" <<'NODE' const fs = require('fs'); const inputPath = process.argv[2]; const data = JSON.parse(fs.readFileSync(inputPath, 'utf8')); NODE ``` - Alternatively, move report processing into a dedicated JavaScript file and provide the path through `process.argv`. - Validate and canonicalize output directories. - Reject paths containing control characters and ensure the resolved path is inside an explicitly approved report root. - Run audit tooling under a minimally privileged account. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
extension/devtools.js:289
Finding
Untrusted Content Rendered Through Extension innerHTML Sinks<![CDATA[ ## Vulnerability Details **File Location**: `extension/devtools.js:289-297`, `extension/devtools.js:418-423`, `extension/devtools.js:479-489`; `extension/popup.js:368-374` **Vulnerability Type**: DOM-based HTML injection in privileged extension pages **Risk Level**: Medium ### Vulnerable Code ```javascript results.violations.forEach((v, i) => { const item = document.createElement('div'); item.className = `violation-item ${v.severity}`; item.innerHTML = ` <div class="violation-header"> <span class="violation-wcag">${v.wcag}</span> <span class="violation-severity ${v.severity}">${v.severity.toUpperCase()}</span> </div> <div class="violation-message">${v.message}</div> <code class="violation-element">${escapeHtml(v.element)}</code> `; item.addEventListener('click', () => highlightElement(v.path)); list.appendChild(item); }); ``` ```javascript log.innerHTML = data.elements.map((el, i) => `<div class="log-entry">${i + 1}. ${el.tag}: "${el.text}"</div>` ).join(''); } catch (error) { log.innerHTML = `<div class="log-entry">Hata: ${error.message}</div>`; } ``` ```javascript if (response.findings) { resultsDiv.innerHTML = response.findings.map(f => ` <div class="ai-finding ${f.severity}"> <strong>${f.wcag}</strong>: ${f.message} </div> `).join(''); } ``` The popup repeats the unsafe AI-result rendering pattern: ```javascript results.findings.forEach(finding => { const li = document.createElement('li'); li.innerHTML = `<strong>${finding.wcag}</strong>: ${finding.message}`; li.style.borderLeftColor = finding.severity === 'critical' ? '#f87171' : finding.severity === 'serious' ? '#fbbf24' : '#60a5fa'; findingsList.appendChild(li); }); ``` ### Technical Analysis The extension inserts page-derived element text and AI or gateway response fields into `innerHTML`. Only `v.element` is escaped in the violation renderer; fields such as `finding.message`, `finding. ...[truncated 1351 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Replace dynamic `innerHTML` construction with `createElement()` and `textContent`. - Treat all page content, model output, gateway output, and error text as untrusted. - Validate `severity` against a fixed allowlist before assigning it as a CSS class. - Parse localhost responses against a strict schema with length and character constraints. - Retain static `innerHTML` only for constant markup that contains no dynamic values. - Add automated tests using payloads such as HTML tags, malformed attributes, and event-handler syntax. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/accessmind-deep-crawler.py:116
Finding
Chromium Sandbox, Site Isolation, and Web Security Disabled During Untrusted Audits<![CDATA[ ## Vulnerability Details **File Location**: `scripts/accessmind-deep-crawler.py:116-130`; related instances at `scripts/full-audit.sh:73-78` and `scripts/real-chrome-audit.py:180,584` **Vulnerability Type**: Deliberate removal of browser security boundaries **Risk Level**: High ### Vulnerable Code ```python self.browser = await playwright.chromium.launch( headless=self.headless, args=[ '--disable-blink-features=AutomationControlled', '--disable-features=IsolateOrigins,site-per-process', '--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage', '--disable-web-security', ] ) ``` The shell-based audit also disables sandboxing: ```bash npx lighthouse "$URL" \ --only-categories=accessibility \ --output=json \ --output-path="$OUTPUT_DIR/lighthouse-$TIMESTAMP.json" \ --chrome-flags="--headless --no-sandbox" \ --quiet ``` ### Technical Analysis The crawler is explicitly intended to visit user-selected and potentially hostile websites. Disabling the Chromium sandbox removes a principal containment boundary for renderer compromise. Disabling site isolation and web security weakens cross-origin separation and may allow audited content to access resources that a normally configured browser would isolate. The combination is substantially more dangerous than a single compatibility flag because it removes multiple independent browser defenses at the same time. ### Attack Path 1. A user audits a malicious or compromised website. 2. The project launches Chromium with sandboxing, site isolation, and web security disabled. 3. The hostile website exploits a browser or renderer vulnerability, or abuses weakened cross-origin restrictions. 4. The reduced browser isolation permits broader access than would be available in a standard Chromium session. 5. The attacker may reach local audit data, other origins, or the host account, depending on the exploited browser weakness and ...[truncated 327 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `--no-sandbox`, `--disable-setuid-sandbox`, `--disable-web-security`, and site-isolation disabling flags. - Use the standard Playwright-managed Chromium security configuration. - If exceptional compatibility requirements remain, execute the entire browser inside a disposable, unprivileged container or VM with: - no host filesystem mounts; - no secrets or cloud credentials; - restricted outbound network access; - a read-only root filesystem; - dropped Linux capabilities; - resource limits. - Document any remaining security-reducing flag and require explicit opt-in. - Do not market disabled browser security controls as safe or isolated execution. ]]>

T08 · Insecure Dependencies

Error
Location
scripts/full-audit.sh:46
Finding
Runtime Execution of Unpinned npm and Python Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `scripts/full-audit.sh:46-78`; related instructions in `references/ci-cd-integration.md:36-38,128-130,193-195,263-265` **Vulnerability Type**: Unpinned package installation and runtime dependency execution **Risk Level**: High ### Vulnerable Code ```bash run_axe_full() { echo "[1/8] Axe-core kapsamlı tarama..." npx @axe-core/cli "$URL" \ --tags "$TAGS" \ --reporter json \ --output "$OUTPUT_DIR/axe-full-$TIMESTAMP.json" 2>/dev/null || { echo "⚠️ Axe-core CLI çalıştırılamadı" } } run_pa11y() { echo "[2/8] Pa11y tarama..." npx pa11y "$URL" \ --standard "WCAG2$LEVEL" \ --reporter json \ --output "$OUTPUT_DIR/pa11y-$TIMESTAMP.json" 2>/dev/null || { echo "⚠️ Pa11y çalıştırılamadı" } } run_lighthouse() { echo "[3/8] Lighthouse denetimi..." npx lighthouse "$URL" \ --only-categories=accessibility \ --output=json \ --output-path="$OUTPUT_DIR/lighthouse-$TIMESTAMP.json" \ --chrome-flags="--headless --no-sandbox" \ --quiet } ``` The CI documentation also recommends unpinned installations: ```yaml - name: Install dependencies run: | pip install accessmind playwright playwright install chromium npm install -g axe-core pa11y ``` ### Technical Analysis `npx` may download and execute a package when a suitable local package is absent. No exact versions, lockfiles, integrity hashes, or `--no-install` control are used. The CI examples likewise install mutable latest versions, including global npm packages. Consequently, the code actually executed during an audit can differ from the code reviewed. Package compromise, dependency confusion, registry account takeover, or an incompatible upstream release can introduce arbitrary installation scripts and runtime behavior. ### Attack Path 1. An attacker compromises an upstream package, one of its transitive depend ...[truncated 667 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Pin every direct dependency to an exact reviewed version. - Commit npm and Python lockfiles with integrity information. - Preinstall dependencies and invoke `npx --no-install` so audits cannot download code implicitly. - Avoid global npm installations. - Use isolated virtual environments and project-local `node_modules`. - Generate and review a software bill of materials. - Enable dependency signature, provenance, vulnerability, and integrity verification in CI. - Require controlled update pull requests instead of resolving latest packages during audit runs. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/agentic-a11y-evaluator.py:848
Finding
Mutable CDN JavaScript Executed Inside Audited Pages<![CDATA[ ## Vulnerability Details **File Location**: `scripts/agentic-a11y-evaluator.py:848-856`; related instances in `scripts/comprehensive-a11y-audit.py:488-495`, `scripts/real-chrome-audit.py:30-41`, and `scripts/wcag-em-evaluator.py:253-257` **Vulnerability Type**: Remote payload retrieval and execution without local integrity verification **Risk Level**: High ### Vulnerable Code ```python await page.goto(TARGET_URL, timeout=60000, wait_until="networkidle") # Run axe-core print("\n🔍 Axe-core analizi çalıştırılıyor...") await page.add_script_tag( url="https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.10.0/axe.min.js" ) ``` Equivalent remote script injection is used by several other audit implementations: ```python await page_obj.goto(page["url"], timeout=60000, wait_until="networkidle") await page_obj.add_script_tag( url="https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.10.0/axe.min.js" ) ``` ### Technical Analysis The audit scripts retrieve JavaScript from an external CDN at runtime and execute it in the audited page. Although the URL contains a version number, the project does not verify a cryptographic digest or ship a reviewed local copy. The effective payload therefore depends on external DNS, TLS, CDN, and upstream account security at execution time. This pattern prevents the reviewed repository from fully determining the code that will execute during an audit. ### Attack Path 1. An attacker compromises the CDN asset, upstream release, DNS path, or another component in the remote delivery chain. 2. A user runs one of the affected audit scripts. 3. Playwright requests `axe.min.js` from the external CDN. 4. The returned JavaScript is injected and executed in the target page context. 5. The changed payload can alter results, access page-visible data, issue network requests, or attack the surrounding browser environment. ### Impact Assessment The direct execution context is the audited page, giving the payload access to that page's D ...[truncated 180 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Vendor a reviewed Axe build inside the project. - Verify the vendored file against an approved cryptographic digest during packaging. - Load the local file with Playwright's `path` option instead of a URL. - If remote retrieval is unavoidable, download the artifact separately, verify a pinned SHA-256 digest, and only then inject it. - Restrict the audit browser's outbound network access to destinations required for the audited site. - Establish a controlled dependency-update process with code review. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/voiceover-navigation-analyzer.py:21
Finding
Global Chrome Processes Can Be Killed and User Cache Recursively Deleted<![CDATA[ ## Vulnerability Details **File Location**: `scripts/voiceover-navigation-analyzer.py:21-41` **Vulnerability Type**: Destructive process and filesystem operations outside the audit workspace **Risk Level**: Medium ### Vulnerable Code ```python async def close_all_browsers(self): """Tüm Chrome süreçlerini kapat""" # MacOS subprocess.run(["pkill", "-9", "Google Chrome"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) # Chrome Driver subprocess.run(["pkill", "-9", "chromedriver"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) time.sleep(2) # Kapanmasını bekle async def clear_browser_data(self): """Browser verilerini temizle""" # Cache, cookies, localStorage temizle subprocess.run(["rm", "-rf", os.path.expanduser("~/Library/Caches/Google/Chrome")], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) async def prepare_for_audit(self, url: str) -> Dict: """Tarama öncesi hazırlık""" await self.close_all_browsers() await self.clear_browser_data() return { "status": "ready", "url": url, "timestamp": datetime.now().isoformat() } ``` ### Technical Analysis The code does not track a browser process created by the audit. Instead, it forcefully kills every process matching broad Chrome and ChromeDriver names. It then recursively removes the user's global Chrome cache rather than using a temporary audit profile. No invocation of `prepare_for_audit()` was identified elsewhere in the reviewed repository, so this is a dormant hazardous capability rather than a confirmed default execution path. It remains directly executable by a caller using the class. ### Attack Path 1. A caller instantiates `ChromeManager` and invokes `prepare_for_audit()`. 2. `pkill -9` immediately terminates all matching Chrome and ChromeDriver processes owned by the user. 3. Unsaved browser work and unrelated auto ...[truncated 571 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove global `pkill` operations. - Store the process handle or PID of the browser launched by the audit and terminate only that process. - Create a dedicated temporary Playwright profile for each audit. - Delete only the audit-owned temporary directory after verifying its canonical path. - Use Python filesystem APIs instead of invoking `rm -rf`. - Require explicit user confirmation for any cleanup outside the report or temporary audit directory. - Add tests ensuring cleanup cannot target the user's normal browser profile. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
extension/manifest.json:8
Finding
Browser Extension Requests All-Site Access Beyond On-Demand Audit Requirements<![CDATA[ ## Vulnerability Details **File Location**: `extension/manifest.json:8-18` and `extension/manifest.json:27-33` **Vulnerability Type**: Excessive browser extension permissions and global content-script injection **Risk Level**: Medium ### Vulnerable Code ```json "permissions": [ "activeTab", "scripting", "storage", "tabs" ], "host_permissions": [ "<all_urls>" ], ``` ```json "content_scripts": [ { "matches": ["<all_urls>"], "js": ["content.js"], "css": ["overlay.css"] } ], ``` ### Technical Analysis The extension already has `activeTab`, which supports user-triggered analysis of the selected page. Nevertheless, it also requests persistent host access to every URL and automatically injects its content script and stylesheet into every matching page. This violates least privilege and unnecessarily places extension code into authentication portals, banking pages, administrative applications, intranet systems, and other sensitive origins. The broad reach magnifies the impact of any current or future extension vulnerability. ### Attack Path 1. A user installs the extension and grants the requested permissions. 2. The browser automatically loads `content.js` on every permitted page, whether or not an audit was requested. 3. A vulnerability in the content script, messaging design, extension UI, or a future update is exposed across all visited origins. 4. A malicious page can interact with the injected extension surface and attempt to influence extension behavior. 5. Any successful extension compromise has a much larger set of sensitive pages available to target. ### Impact Assessment The permissions increase the blast radius of extension defects to virtually all websites visited by the user. The extension also possesses scripting, tabs, and storage capabilities, making least-privilege reduction important even though no direct credential-harvesting behavior was found. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `<all_urls>` from persistent host permissions. - Remove the globally registered content script. - Use `activeTab` and inject audit code only after an explicit user action. - If persistent access is required for selected sites, use optional host permissions and request the narrowest origin at runtime. - Exclude privileged, browser-internal, file, and local administrative origins. - Document precisely why each permission is necessary. - Add extension-store permission-change review and automated manifest linting. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
extension/background.js:56
Finding
Sensitive Screenshots Sent to Unauthenticated Plaintext Localhost Services<![CDATA[ ## Vulnerability Details **File Location**: `extension/background.js:5-6`, `extension/background.js:56-70`, and `extension/background.js:108-119` **Vulnerability Type**: Unauthenticated local service communication and sensitive-data disclosure **Risk Level**: Medium ### Vulnerable Code ```javascript const OPENCLAW_GATEWAY = 'http://127.0.0.1:8765'; // OpenClaw Gateway endpoint const QWEN_MODEL = 'qwen3-vl:latest'; ``` ```javascript async function sendToGateway(screenshot, url) { try { const response = await fetch(`${OPENCLAW_GATEWAY}/api/visual-analysis`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ image: screenshot, url: url, model: QWEN_MODEL, analysis_type: 'accessibility' }) }); if (!response.ok) { throw new Error(`Gateway error: ${response.status}`); } const data = await response.json(); return data; } catch (error) { throw error; } } ``` ```javascript const ollamaResponse = await fetch('http://127.0.0.1:11434/api/generate', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ model: QWEN_MODEL, prompt: prompt, images: [screenshot.replace('data:image/png;base64,', '')], stream: false }) }); ``` ### Technical Analysis Visible-tab screenshots and page URLs are sent to fixed localhost HTTP ports without authentication, service identity verification, request signing, or confidentiality beyond loopback routing. Loopback does not guarantee that the intended program owns the destination port. Another process running under the same user, malware, or an unintended local service can bind the expected port and impersonate the gateway. The returned JSON is also trusted and later rendered through unsafe `innerHTML` sinks. ### Attack Path 1. A malicious or unintended local process binds port `8765` or `11434` before the int ...[truncated 816 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Obtain clear user consent immediately before transmitting a screenshot. - Authenticate the local service with a high-entropy per-installation secret. - Prefer authenticated operating-system IPC, such as a restricted Unix-domain socket or browser native messaging, over unauthenticated HTTP. - Verify service identity and reject unexpected response content types and schemas. - Apply strict response size, field length, and value allowlists. - Do not return or persist the original screenshot unless required. - Provide an option to disable all AI transmission and clearly show the destination before analysis. - Combine this fix with removal of the unsafe `innerHTML` rendering sinks. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Output HandlingUnvalidated Output Injection, Cross-Context Output, Unbounded Output
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (152)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The finding suggests no real implementation for many advertised features and also a hardcoded target URL, making the skill much narrower than described. This is dangerous because broad trigger phrases may activate a tool that does something materially different from what the user intended.

Unvalidated Output Injection

High
Category
Output Handling
Content
});
    
    if (response.findings) {
      resultsDiv.innerHTML = response.findings.map(f => `
        <div class="ai-finding ${f.severity}">
          <strong>${f.wcag}</strong>: ${f.message}
        </div>
Confidence
98% confidence
Finding
The code inserts AI response fields into innerHTML using template literals without escaping f.severity, f.wcag, or f.message. If the background service, model output, or any upstream component returns attacker-controlled HTML, this can trigger DOM XSS in the extension DevTools context, which is especially dangerous because extension contexts often have elevated privileges and access to sensitive extension APIs.

Hidden Instructions

High
Category
Prompt Injection
Content
### Landmark Roles

```html
<!-- Otomatik landmark'lar -->
<header> → role="banner"
<nav> → role="navigation"
<main> → role="main"
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
<header>...</header>
  
  <main id="main-content">
    <!-- Ana içerik -->
  </main>
</body>
```
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
**Örnekler:**
```html
<!-- Bilgi veren -->
<img src="chart.png" alt="2024 satış grafik: %25 artış">

<!-- Dekoratif -->
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Hidden Instructions

High
Category
Prompt Injection
Content
**Örnekler:**
```html
<!-- Bilgi veren -->
<img src="chart.png" alt="2024 satiş grafik: %25 artiş">

<!-- Dekoratif -->
Confidence
70% confidence
Finding
Hidden instructions were detected in comments or invisible text. These could contain malicious directives. Manual review is recommended.

Static analysis

No suspicious patterns detected.