Back to skill

Security audit

App Store Server API

Security checks for vulnerabilities and agentic risk

Overview

The skill is purpose-aligned for App Store Server API work, but it under-controls irreversible App Store state changes and recommends unverified remote installer execution.

Review this skill before installing. It can operate on sensitive App Store commerce data and should be used only with a least-privilege OOMOL connection. Require explicit approval for every operation that changes subscriptions, transactions, consumption information, or app account tokens, especially bulk renewal extensions. Prefer a verified package-manager or checksum-verified CLI install path instead of running the remote installer pipe commands as written.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
SKILL.md:69
Finding
Unverified Remote Installer Scripts Are Executed Directly## Vulnerability Details **File Location**: `SKILL.md:69-73` **Vulnerability Type**: Remote payload retrieval and immediate execution **Risk Level**: High ### Complete Code Snippet ```bash curl -fsSL https://cli.oomol.com/install.sh | bash # macOS / Linux ``` ```powershell irm https://cli.oomol.com/install.ps1 | iex # Windows PowerShell ``` ### Technical Analysis The setup instructions retrieve mutable scripts from `cli.oomol.com` and immediately execute their contents in Bash or PowerShell. Neither command pins a specific installer version, verifies a cryptographic signature or checksum, nor gives the user an opportunity to inspect the downloaded script. Consequently, the effective code executed on a user's system can change after the Skill has been reviewed. HTTPS protects the connection in transit but does not protect against compromise of the hosting infrastructure, malicious modification of the installer, loss of control over the domain, or unauthorized publication. Installing the CLI may be necessary for the declared functionality, but executing an unverified remote script is not the minimum privilege or safest installation method required to provide that functionality. ### Attack Path 1. The `oo` command is unavailable on the user's system. 2. The Skill follows its first-time setup instructions. 3. An attacker compromises the installer host, publication process, or other trusted delivery infrastructure. 4. The attacker replaces the installer response with arbitrary shell commands. 5. `bash` or PowerShell executes the response immediately under the invoking user's privileges. 6. The payload can alter the host before installing—or pretending to install—the expected CLI. ### Impact Assessment Successful exploitation provides arbitrary command execution with the privileges of the user running the installation. Depending on those privileges and the host configuration, an attacker could: - ...[truncated 318 chars]
Remediation
## Remediation Suggestions - Do not pipe downloaded content directly into a shell or use `Invoke-Expression`. - Direct users to a version-pinned package or release artifact from a verifiable source. - Download the installer to a local file before execution. - Publish and verify a SHA-256 or stronger checksum over the downloaded artifact. - Prefer cryptographic signature verification using a separately distributed trusted public key. - Display the resolved version, source, checksum, and intended installation paths before requesting explicit user approval. - Run installation with ordinary user privileges unless a specific operation demonstrably requires elevation. - Recommend platform package managers with signature and provenance controls where available.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:39
Finding
Irreversible State-Changing Actions Are Incorrectly Classified as Safe Reads## Vulnerability Details **File Location**: `SKILL.md:39-41`, with the unsafe policy at `SKILL.md:58-60` **Vulnerability Type**: Incorrect authorization and confirmation policy for remote mutations **Risk Level**: High ### Complete Code Snippet ```text - `extend_renewal_date_for_all_active_subscribers` — Extend the renewal date of every active subscription to one product, optionally limited to some storefronts. The App Store processes the request asynchronously; poll get_subscription_renewal_date_extension_status for the outcome. The extension cannot be reversed. - `extend_subscription_renewal_date` — Extend the renewal date of one customer's active auto-renewable subscription, to compensate for a service outage or a cancelled event. The extension cannot be reversed, and Apple emails the customer about the new renewal date. - `finish_transaction` — Tell the App Store that your server finished delivering the content for a transaction. Call it only after the customer has the content; it cannot be undone. Apple still returns a finished transaction from get_transaction_history, so do not treat its disappearance as confirmation. ``` ```text - Untagged actions are reads (get / list / search) — safe to run directly. - **Actions tagged `[write]` change App Store Server API state — confirm the exact payload and effect with the user before running.** - **Actions tagged `[destructive]` remove or overwrite data — always confirm the target and get explicit approval first.** ``` ### Technical Analysis The three listed operations expressly change remote App Store state and are described as irreversible or non-reversible. However, none is tagged `[write]` or `[destructive]`. The safety policy states that every untagged action is a read and is safe to run directly. As a result, the Skill's own authorization logic permits these operations without showing the exact payload or obtaining explicit approval. This is a fail-open classification sc ...[truncated 1599 chars]
Remediation
## Remediation Suggestions - Tag `extend_renewal_date_for_all_active_subscribers`, `extend_subscription_renewal_date`, and `finish_transaction` as `[write]`; consider `[destructive]` for irreversible operations. - Require explicit user approval immediately before every state-changing invocation. - Present the action name, application, environment, customer or product target, storefront scope, and complete normalized payload before confirmation. - Add a separate high-friction confirmation for bulk subscriber operations. - Treat missing action metadata as unsafe rather than as read-only. - Maintain an explicit allowlist of verified read-only operations. - Compare local action metadata with the live connector schema and reject execution when mutability information is missing or inconsistent. - Add post-execution reporting that includes the execution ID and the exact approved action.

T01 · Skill Instruction Hijacking

Warning
Location
SKILL.md:3
Finding
Mandatory Third-Party Routing Expands Exposure of App Store Customer and Transaction Data## Vulnerability Details **File Location**: `SKILL.md:3-4`, with connector behavior at `SKILL.md:14`, `SKILL.md:23`, and `SKILL.md:29` **Vulnerability Type**: Skill instruction hijacking and unnecessary expansion of the data trust boundary **Risk Level**: Medium ### Complete Code Snippet ```yaml description: "App Store Server API (developer.apple.com). Use this skill for ANY App Store Server API request — reading, creating, and updating data. Whenever a task involves App Store Server API, use this skill instead of calling the API directly." allowed-tools: [Bash(oo *)] ``` ```text Operate **App Store Server API** through your OOMOL-connected account. This skill calls the `app_store_server` connector with the [oo CLI](https://github.com/oomol-lab/oo-cli); OOMOL injects credentials server-side, so you never handle raw tokens. ``` ```bash oo connector schema "app_store_server" --action "<action_name>" ``` ```bash oo connector run "app_store_server" --action "<action_name>" --data '<json>' --json ``` ### Technical Analysis The Skill instructs the agent to use it for every App Store Server API request and explicitly forbids choosing a direct API route. Action payloads are sent through the OOMOL connector rather than directly to Apple. Depending on the selected action, those payloads and responses may contain transaction identifiers, order identifiers, customer subscription records, app account tokens, refund information, consumption information, and decoded signed payload data. Although the document states that OOMOL injects credentials server-side, it does not define data retention, logging, redaction, regional processing, or access-control behavior for the intermediary. Use of a connector is consistent with the Skill's advertised integration model. The risk arises from the unconditional instruction to override tool selection for all matching requests, including cases where direct Apple API access c ...[truncated 1641 chars]
Remediation
## Remediation Suggestions - Replace the unconditional “ANY” and “instead of calling the API directly” instructions with conditional guidance. - Allow the agent or user to select direct Apple API access where available and appropriate. - Obtain informed user consent before transmitting customer or transaction data through OOMOL. - Document precisely which request and response fields OOMOL receives, logs, retains, and can access. - State retention periods, processing regions, encryption controls, and deletion procedures. - Minimize each payload to fields required by the live action schema. - Redact sensitive values from command output, diagnostic logs, and execution histories. - Apply least-privilege scopes to the connected account and separate read-only from write-capable connections where possible. - Require additional approval before sending app account tokens, consumption details, or bulk-operation payloads.
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.