CVE-2026-32053: Openclaw Auth Bypass Vulnerability

CVE-2026-32053 Overview

OpenClaw versions prior to 2026.2.23 contain a vulnerability in the Twilio webhook event deduplication mechanism where normalized event IDs are randomized per parse. This flaw allows replay events to bypass the manager's dedupe checks, enabling attackers to replay Twilio webhook events to trigger duplicate or stale call-state transitions. This can result in incorrect call handling and state corruption within the voice-call extension.

Critical Impact
Attackers can exploit randomized event ID normalization to bypass deduplication controls, enabling webhook replay attacks that corrupt call state and disrupt telephony operations.

Affected Products

OpenClaw versions prior to 2026.2.23
OpenClaw Node.js package (cpe:2.3:a:openclaw:openclaw:*:*:*:*:*:node.js:*:*)
OpenClaw voice-call extension with Twilio webhook integration

Discovery Timeline

2026-03-21 - CVE-2026-32053 published to NVD
2026-03-24 - Last updated in NVD database

Technical Details for CVE-2026-32053

Vulnerability Analysis

This vulnerability represents an Authentication Bypass weakness classified under CWE-294 (Authentication Bypass by Capture-replay). The core issue lies in how OpenClaw's voice-call extension normalizes and deduplicates incoming Twilio webhook events. When webhook events are parsed, the normalization process generates randomized event IDs rather than deterministic identifiers. This non-deterministic behavior means that identical webhook events can receive different internal IDs upon each parse operation.

The deduplication mechanism in the call manager relies on event IDs to prevent processing the same webhook event multiple times. However, because each parse produces a unique randomized ID, the processedEventIds Set fails to recognize previously processed events. An attacker who captures legitimate Twilio webhook requests can replay them, and each replay will be treated as a novel event due to the randomized ID generation.

Root Cause

The root cause is the absence of a stable deduplication key in the event normalization logic. The original implementation used event.id directly for deduplication, but this ID was regenerated with random values during each parse operation. Without a consistent identifier tied to the actual webhook event content, the system cannot reliably detect replay attempts.

Attack Vector

An attacker positioned to intercept or observe Twilio webhook traffic can capture legitimate webhook event payloads. By replaying these captured events to the OpenClaw webhook endpoint, the attacker can:

Trigger duplicate call-state transitions, causing calls to enter invalid states
Replay stale events to revert call states to previous conditions
Corrupt active call sessions by injecting out-of-sequence state changes
Potentially cause denial of service by overwhelming the system with replayed events

The vulnerability is exploitable over the network without authentication, requiring no user interaction to trigger.

typescript

// Vulnerable code - event.id was randomized per parse
export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
  if (ctx.processedEventIds.has(event.id)) {
    return;
  }
  ctx.processedEventIds.add(event.id);
  // ... event processing continues
}

Source: GitHub Commit Update

typescript

// Fixed code - uses stable dedupeKey for consistent identification
export function processEvent(ctx: EventContext, event: NormalizedEvent): void {
  const dedupeKey = event.dedupeKey || event.id;
  if (ctx.processedEventIds.has(dedupeKey)) {
    return;
  }
  ctx.processedEventIds.add(dedupeKey);
  // ... event processing continues
}

Source: GitHub Commit Update

Detection Methods for CVE-2026-32053

Indicators of Compromise

Unusual volume of duplicate webhook requests from Twilio endpoints with identical payload content but processed as separate events
Call state inconsistencies where calls unexpectedly revert to previous states or enter invalid transition sequences
Log entries showing multiple successful processing of events that should have been deduplicated
Anomalous call handling behavior such as duplicate notifications or repeated state callbacks

Detection Strategies

Implement webhook request logging with payload hashing to identify duplicate content arriving with different internal event IDs
Monitor for rapid sequential webhook events targeting the same call session with identical or near-identical timestamps
Deploy network-level request deduplication or rate limiting on Twilio webhook endpoints
Compare Twilio's webhook delivery logs against application-processed event counts to identify discrepancies

Monitoring Recommendations

Enable detailed audit logging for all Twilio webhook events including raw payload signatures and processing outcomes
Set up alerts for call state corruption patterns such as invalid state transitions or unexpected state reversions
Monitor the processedEventIds Set growth rate for anomalies indicating deduplication bypass
Track webhook endpoint response latencies and error rates that may indicate replay attack attempts

How to Mitigate CVE-2026-32053

Immediate Actions Required

Upgrade OpenClaw to version 2026.2.23 or later immediately to receive the security patch
Review call logs and state transition histories for signs of exploitation or state corruption
Implement Twilio webhook signature validation if not already enabled to ensure request authenticity
Consider temporarily restricting access to webhook endpoints to known Twilio IP ranges while patching

Patch Information

The fix introduces a stable dedupeKey property to normalized events that provides a consistent identifier for deduplication regardless of parse iteration. The patched processEvent function in extensions/voice-call/src/manager/events.ts now uses event.dedupeKey || event.id for the deduplication check, ensuring that replayed events are properly recognized and blocked.

Additionally, a turnToken property has been added to the call manager runtime state in extensions/voice-call/src/manager/context.ts to strengthen state transition validation.

For full patch details, see the GitHub Commit Update and GitHub Security Advisory.

Workarounds

Implement external request deduplication at the API gateway or reverse proxy level using payload hashing
Enable Twilio webhook signature validation with strict timestamp tolerance to reject stale requests
Deploy rate limiting on webhook endpoints to reduce the impact of replay attacks
Consider implementing application-level request fingerprinting based on Twilio's native event identifiers

bash

# Example: Configure rate limiting on webhook endpoint (nginx)
location /webhooks/twilio {
    limit_req zone=twilio_webhooks burst=10 nodelay;
    limit_req_status 429;
    proxy_pass http://openclaw_backend;
}