Back to skill

Security audit

Cal.com

Security checks for vulnerabilities and agentic risk

Overview

The skill is a disclosed Cal.com integration with real credential and automation risks, but its sensitive behaviors are described and mostly gated on explicit user approval.

Before installing, understand that this skill can access and change Cal.com scheduling data through your Maton connection. Approve writes, webhooks, hosted functions, and triggers only after reviewing the exact target, payload, destination URL, and persistence. For hosted functions, use a Maton account that has only the connections the function needs, and remove functions, triggers, webhooks, or connections when they are no longer needed.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
Findings (2)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:184
Finding
Hosted Functions Inherit Account-Wide Maton Authority<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 184-210 **Vulnerability Type**: Excessive runtime privileges and insufficient credential scoping **Risk Level**: High ### Vulnerable Code Snippet ```markdown > **Execution identity.** A function runs as the Maton account that deployed it — the same identity > as the `maton` CLI session that performed the deploy, no more and no less. It receives that > identity as a runtime-injected `MATON_API_KEY`: the key is placed in the sandbox's environment > only while the function runs, is never stored in the package or the code, is never set through > `function env`, and only the authenticated account owner can create, deploy, or update a function. > > **Before any deploy or invocation, give the user a least-privilege summary and get approval on it:** the handler > (which they wrote or reviewed — never deploy code they did not), the connections the deploying > account holds (`maton connection list`), which is exactly what the function will be able to reach, > and the network policy. Prefer an account whose connections are only the ones the function needs. ``` ### Technical Analysis A hosted function receives a runtime-injected `MATON_API_KEY` representing the identity of the entire deploying Maton account. The document explicitly states that all connections held by that account are available to the function. This exceeds the minimum privilege required for a function intended to perform a specific Cal.com operation. The restriction that a function should access only the connection for which it was written is policy-based rather than enforced through a connection-scoped credential. The `DENY_ALL` network policy reduces exposure by preventing arbitrary outbound connections, but it does not establish application-level authorization boundaries inside the Maton platform. A function can still use the injected account credential to access other applications or connections available through the Maton gat ...[truncated 1606 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the account-wide runtime credential with a short-lived, function-specific token. 2. Bind the token to an explicit allowlist containing: - Permitted application, such as `cal-com`. - Permitted connection IDs. - Permitted API paths. - Permitted HTTP methods. 3. Require a machine-enforced permission manifest when a function is created or deployed. 4. Reject undeclared application or endpoint access at the Maton gateway. 5. Ensure trigger invocation does not widen the function’s original authorization scope. 6. Require separate approval whenever a function’s code or permission manifest changes. 7. Record and expose audit logs showing the application, connection, endpoint, and method used by each function invocation. 8. Prefer dedicated Maton accounts containing only the connections required for a function until granular capability tokens are available. 9. Preserve the existing `DENY_ALL` outbound-network default, but do not treat it as a substitute for gateway-level authorization controls. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:33
Finding
Third-Party Tooling Is Installed Without Artifact Integrity Verification<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md`, lines 33-45 and 1504-1528 **Vulnerability Type**: Unverified third-party dependency installation **Risk Level**: Medium ### Vulnerable Code Snippet ```bash npm install -g @maton/cli@0.3.1 ``` ```bash brew install maton-ai/cli/maton brew pin maton ``` ```bash pip install 'maton-ai==0.3.1' ``` ```bash npm install @maton/sdk@0.3.1 ``` ### Technical Analysis The Skill instructs users to retrieve and execute packages from npm, PyPI, and a custom Homebrew tap. Version pinning is a positive control because it limits unreviewed upgrades, but a version pin alone does not authenticate the artifact obtained from a registry or tap. The instructions do not provide checksums, signature verification, provenance attestations, or reproducible-build guidance. Consequently, compromise of a package publisher, registry account, distribution channel, or custom tap could cause the installation of attacker-controlled code under a legitimate package name and pinned version. The global npm installation has additional impact because it modifies the user’s shared executable environment. The installed CLI is subsequently used for OAuth login and authenticated API operations, so a compromised package would be positioned to access credentials or alter requests. No evidence was found that the named packages are currently malicious. This finding concerns the absence of artifact-integrity controls in a security-sensitive installation path. ### Attack Path 1. An attacker compromises a package publisher, registry account, distribution channel, or Homebrew tap used by the documented installation commands. 2. A malicious artifact is published or substituted for the expected pinned release. 3. The user follows the Skill instructions and installs the artifact. 4. Installation hooks or the installed executable run with the user’s local privileges. 5. The compromised CLI or SDK observes authentication activity, alters API requ ...[truncated 846 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Publish SHA-256 or stronger checksums for every supported CLI and SDK artifact. 2. Provide signature or provenance-verification steps before installation. 3. Use signed release artifacts and verifiable build attestations such as Sigstore provenance where supported. 4. Document the authoritative npm organization, PyPI publisher, and Homebrew tap ownership. 5. Prefer isolated installation environments over global package installation: - Use a dedicated virtual environment for Python. - Use a project-local npm installation or isolated package runner. - Avoid modifying a shared executable path unless necessary. 6. Pin dependencies with lockfiles and integrity hashes for SDK-based projects. 7. Publish an SBOM for reviewed releases. 8. Advise users to verify artifact identity and integrity before authenticating with the installed tool. 9. Document revocation and incident-response procedures for compromised releases, including credential rotation and removal of affected packages. ]]>
Vulnerability Patterns
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep

Static analysis

No suspicious patterns detected.