Back to skill

Security audit

opentable

Security checks for vulnerabilities and agentic risk

Overview

This OpenTable skill is coherent for restaurant reservations, but it asks users to run unpinned external code and a shared browser extension through a signed-in OpenTable session.

Review this before installing. Use a dedicated browser profile if possible, pin the MCP package and extension to reviewed versions, and only keep the extension running while you need it. Treat booking, modifying, and cancelling as account-changing actions, especially when a reservation can involve a saved card or no-show fee.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (2)

T08 · Insecure Dependencies

Error
Location
SKILL.md:23
Finding
Automatic Execution of an Unpinned npm Package<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 23–34 **Vulnerability Type**: Unpinned third-party executable dependency **Risk Level**: High ### Vulnerable Code ```markdown Add to `.mcp.json` in your project or `~/.claude/mcp.json`: ```json { "mcpServers": { "opentable": { "command": "npx", "args": ["-y", "opentable-mcp"] } } } ``` ``` ### Technical Analysis The recommended configuration executes `opentable-mcp` using `npx -y` without specifying an exact version or package integrity value. The `-y` option suppresses the normal installation confirmation, while the absence of a version pin allows npm to resolve a package release that may differ from the release originally reviewed. This creates a mutable supply-chain execution path. Compromise of the npm package, its maintainer account, the registry entry, or a transitive dependency could cause attacker-controlled JavaScript and npm lifecycle scripts to execute when the MCP server is launched. The alternative source installation documented later in the file also clones a mutable repository branch and runs `npm install && npm run build` without pinning a reviewed commit. It therefore presents a similar, although separately delivered, supply-chain risk. ### Attack Path 1. An attacker compromises the `opentable-mcp` npm package, a maintainer account, or one of its resolved dependencies. 2. The attacker publishes a malicious package version or modifies an install-time dependency. 3. A user follows the recommended MCP configuration. 4. The MCP client invokes `npx -y opentable-mcp`. 5. `npx` automatically retrieves and executes the currently resolved package without user confirmation. 6. The malicious package runs with the operating-system privileges of the user running the Agent or MCP client. 7. It may access resources available to that user, alter local files, steal locally accessible data, or misuse the authenticated browser relay. ### Impact Assessment Suc ...[truncated 632 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the floating package reference with an exact, reviewed version, for example: ```json { "command": "npx", "args": ["--no-install", "opentable-mcp@<reviewed-version>"] } ``` 2. Install the reviewed package separately using a lockfile and verified npm integrity metadata, then prevent `npx` from downloading a replacement at runtime. 3. Remove `-y` so package installation or replacement cannot occur silently. 4. Publish checksums, signatures, provenance attestations, and reproducible build instructions for approved artifacts. 5. Audit and lock transitive dependencies with `npm ci` and a committed lockfile. 6. For source installation, pin the clone to a reviewed commit SHA rather than a mutable branch: ```bash git clone https://github.com/chrischall/opentable-mcp cd opentable-mcp git checkout <reviewed-commit-sha> npm ci --ignore-scripts ``` 7. Review all required lifecycle scripts before enabling them. 8. Run the MCP process in a sandbox with minimal filesystem, environment-variable, process, and network access. ]]>

T08 · Insecure Dependencies

Error
Location
SKILL.md:57
Finding
Unpinned External Browser Extension Operates Through an Authenticated Session<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 57–70 **Vulnerability Type**: Privileged external dependency with authenticated-browser access **Risk Level**: High ### Vulnerable Code ```markdown ### 2. Install the fetchproxy extension opentable-mcp shares a single browser extension with every other fetchproxy-based MCP. Install it once from [github.com/chrischall/fetchproxy](https://github.com/chrischall/fetchproxy): 1. Install the fetchproxy extension (Chrome Web Store / Safari `.dmg`). 2. Sign in to `https://www.opentable.com/` in the same browser profile. The extension's toolbar badge turns green when the WebSocket + tab + auth are all good. Full extension walkthrough: see [fetchproxy](https://github.com/chrischall/fetchproxy). ## Authentication No env vars. Auth is whatever cookies your signed-in opentable.com tab has. If Akamai rotates `_abck` or OpenTable's SSO expires, visit opentable.com and click through whatever prompt appears — subsequent MCP calls will use the fresh cookies automatically. ``` The broader relay behavior is also stated at line 8: ```markdown Every request is relayed through the user's signed-in browser tab via the [fetchproxy](https://github.com/chrischall/fetchproxy) extension ``` ### Technical Analysis The Skill requires an externally distributed browser extension to relay MCP requests through a browser profile containing an authenticated OpenTable session. Using the authenticated session is functionally related to managing reservations, but the extension becomes a privileged intermediary capable of submitting requests as the signed-in user and observing returned data. The documentation does not pin an extension release, commit, checksum, or signature. The extension implementation is not included in this project, so the audit cannot verify: - Which browser permissions it requests. - Whether it accepts only OpenTable destinations and approved endpoints. - Whether arbitrary URLs, methods, headers, ...[truncated 2337 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the browser extension to a reviewed, signed release or immutable commit and publish its checksum. 2. Include the extension source in the audited distribution or provide a reproducible build process that maps reviewed source to the installed artifact. 3. Restrict extension host permissions to exact required OpenTable origins. Do not request access to unrelated sites or all browsing data. 4. Enforce an explicit allowlist of required OpenTable endpoints, HTTP methods, and request fields. Reject arbitrary URL forwarding and arbitrary header injection. 5. Authenticate and authorize every WebSocket client using a per-installation secret or mutually authenticated local channel. 6. Bind the relay only to loopback interfaces and prevent access from other network hosts. 7. Isolate each MCP integration rather than sharing one unrestricted relay among unrelated MCP servers. 8. Require clear, fresh user confirmation before booking, modification, cancellation, or any operation that may incur a fee. 9. Return a strict allowlist of required response fields instead of untouched upstream payloads, particularly for profile and reservation responses. 10. Redact confirmation numbers, security tokens, booking tokens, phone numbers, email addresses, and saved-card metadata unless they are necessary for the immediate user-approved operation. 11. Document the extension's permissions, update policy, data retention, local transport security, and complete request flow. 12. Use a separate browser profile dedicated to OpenTable so compromise of the integration cannot directly reach unrelated authenticated browsing sessions. ]]>
Vulnerability Patterns
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (3)

MCP Config Access

High
Category
Agent Snooping
Content
#### Option A — npx (recommended)

Add to `.mcp.json` in your project or `~/.claude/mcp.json`:

```json
{
Confidence
95% confidence
Finding
Skill accesses MCP server configuration files (mcp.json). MCP configs contain server URLs, authentication tokens, and tool definitions — reading them allows the skill to discover and potentially abuse other tool integrations.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The trigger description ends with a broad catch-all phrase covering 'any request involving OpenTable restaurant reservations', which can cause the skill to activate on loosely related user prompts. Overbroad activation increases the chance of unintended tool use against a signed-in OpenTable session, including exposing reservation/profile data or initiating booking/cancellation flows in contexts where the user did not explicitly intend to invoke this skill.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
The six read tools — `opentable_search_restaurants`, `opentable_get_restaurant`,
`opentable_find_slots`, `opentable_list_reservations`, `opentable_get_profile`
and `opentable_list_favorites` — take `view: "compact" | "full"`, and
**`compact` is the default**. You get the slim rung without asking for it; an
efficiency a caller has to know about and request is one that usually is not
requested, and the caller paying for it is the one least able to know it exists.
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Static analysis

No suspicious patterns detected.