Back to skill

Security audit

MicroSaaS Launcher

Security checks for vulnerabilities and agentic risk

Overview

The skill is purpose-aligned for launching a micro-SaaS, but it asks for broad production, credential, financial-data, public-posting, and persistent scheduling authority without enough scoping or safeguards.

Install only if you are prepared to supervise it closely. Use project-scoped, short-lived tokens; never provide account passwords; keep secrets out of source code, logs, chat, and command arguments; require a privacy notice before collecting waitlist or support data; and replace the automatic cron job with a reviewed, removable, least-privilege scheduler.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
Findings (4)

T06 · System Persistence

Error
Location
SKILL.md:126
Finding
Persistent Daily Cron Job Executes Beyond the Initiating Session## Vulnerability Details **File Location**: `SKILL.md`, lines 126-129 **Vulnerability Type**: T06: System Persistence **Risk Level**: High **Vulnerable Code Snippet**: ```markdown 16. **Daily Revenue Reporting (Cron Job):** * **Action:** Set up a daily cron job that fetches revenue data from Stripe and reports it to the user. * **Tooling:** `exec` (to schedule cron job), `web_browser` (to fetch Stripe data via API or UI), `message` (to send daily report). * **Logging:** Record daily revenue reports in `LAUNCH-LOG.md`. ``` ### Technical Analysis The Skill directs the Agent to modify the host's task scheduler by installing a daily cron job. A scheduled task survives the original Skill invocation and continues executing across sessions. The instructions do not define the generated command, execution identity, credential scope, expiration time, removal process, or integrity controls for the script executed by cron. Because the scheduled process fetches Stripe revenue information and sends reports, it will require continuing access to sensitive financial data and a communication channel. If the scheduled script, its configuration, or a writable dependency is compromised, the cron entry becomes a durable execution mechanism. ### Attack Path 1. The Agent reaches the maintenance phase of the runbook. 2. It creates a reporting script or command with access to Stripe data. 3. It invokes `exec` to install that command in a cron schedule. 4. The cron service executes the command every day after the initiating Agent session has ended. 5. An attacker who can alter the script, configuration, executable search path, or credentials used by the task can obtain recurring code execution or financial-data access. ### Impact Assessment Successful exploitation can provide persistent execution with the privileges of the account that owns the cron entry. The accessible scope can include Stripe revenue data, environment ...[truncated 179 chars]
Remediation
## Remediation Suggestions - Do not install host-level cron entries automatically. - Generate a proposed scheduling configuration for user review and require explicit confirmation immediately before enabling it. - Prefer a project-scoped managed scheduler with a clearly identified owner, execution identity, and expiration policy. - Run the task under a dedicated least-privileged service account. - Use a restricted, read-only Stripe credential that can access only the required reporting information. - Store credentials in an approved secret manager rather than in scripts, cron command lines, source files, or logs. - Use absolute executable and script paths, immutable or access-controlled scripts, and a minimal environment. - Document how to inspect, disable, and remove the scheduled task. - Add expiration, failure notification, execution logging, and credential-rotation procedures.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:93
Finding
Stripe Secrets May Be Written into Source Code and Committed to Git## Vulnerability Details **File Location**: `SKILL.md`, lines 65-69 and 93-98 **Vulnerability Type**: T09: Insecure Skill Coding Practices **Risk Level**: High **Vulnerable Code Snippets**: ```markdown 7. **Code Generation & Implementation:** * **Action:** Based on the validated MVP features, write the entire codebase. This includes: * Next.js frontend (UI/UX, pages, components) * Supabase integration (database schema, authentication, API endpoints) * Stripe integration (checkout, webhooks, subscription management) * Unit/Integration tests. * **Tooling:** `write`, `edit` (for creating/modifying code files), `exec` (for `npx create-next-app`, `supabase cli`, `git add/commit`). * **Output:** All project code files committed to the GitHub repository. ``` ```markdown 10. **Stripe Integration & Pricing Tiers:** * **Action:** Configure Stripe API keys, create product and pricing tiers (e.g., Free, Pro, Premium) as per validated features. Ensure webhooks are set up for Supabase. * **Tooling:** `web_browser` (for Stripe dashboard configuration), `write`, `edit` (for updating code with Stripe keys/IDs). * **Output:** Confirmed Stripe integration and pricing plans. * **Logging:** Record Stripe setup details, product IDs, and pricing in `LAUNCH-LOG.md`. * **Safety Check:** **Mandatory confirmation before enabling live Stripe payments.** ``` ### Technical Analysis The runbook instructs the Agent to configure Stripe API keys by updating code and separately requires all project code to be committed. It does not distinguish secret API keys from non-secret identifiers, require environment-variable injection, prohibit secret logging, mandate `.gitignore` rules, or require secret scanning before commits. A live Stripe secret key accidentally placed in source code, configuration, command history, or `LAUNCH-LOG.md` can remain recov ...[truncated 1321 chars]
Remediation
## Remediation Suggestions - Explicitly prohibit placing secret API keys, webhook secrets, passwords, or tokens in source files, documentation, logs, chat transcripts, and command-line arguments. - Commit only environment-variable names and safe placeholders, such as `STRIPE_SECRET_KEY`, without values. - Store production secrets in Vercel's protected environment configuration or another approved secret manager. - Separate publishable Stripe keys from secret keys and clearly document that only publishable keys may appear in client-side code. - Use restricted Stripe keys with the minimum permissions required by each component. - Add `.env`, `.env.local`, credential exports, and generated secret files to `.gitignore` before any secret is introduced. - Run automated secret scanning against the working tree, staging area, commit history, and `LAUNCH-LOG.md` before every push. - Redact sensitive values from operational logs and record only non-secret resource identifiers where necessary. - If a key is committed, revoke and rotate it immediately, purge it from Git history, invalidate cached artifacts, and review Stripe audit logs for misuse.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:46
Finding
Use of Broad User Credentials and API Tokens Violates Least Privilege## Vulnerability Details **File Location**: `SKILL.md`, lines 46-49 and 79-81 **Vulnerability Type**: T05: Unauthorized Access and Privilege Escalation **Risk Level**: High **Vulnerable Code Snippets**: ```markdown 5. **GitHub Repository Creation:** * **Action:** Create a new private GitHub repository for the project. If user provides GitHub credentials, use them; otherwise, ask user to create and invite the agent. * **Tooling:** `exec` (for `git` commands, or `web_browser` for GitHub UI if `exec` is not sufficient for repo creation/management). * **Output:** Repository URL. * **Logging:** Record GitHub repo URL in `LAUNCH-LOG.md`. ``` ```markdown 8. **Vercel Deployment:** * **Action:** Deploy the Next.js application to Vercel. Obtain Vercel API token or guide user to connect GitHub repo to Vercel. * **Tooling:** `exec` (for `vercel deploy` CLI, or `web_browser` for Vercel UI). * **Output:** Live Vercel deployment URL. ``` ### Technical Analysis The Skill permits direct use of unspecified GitHub credentials and instructs the Agent to obtain a Vercel API token. It does not require delegated authorization, define minimum scopes, prohibit passwords, constrain token lifetime, or establish secure handling and revocation requirements. A broad personal access token or account credential may authorize operations unrelated to the new micro-SaaS project. Using such credentials through command-line tools or browser automation can also expose them through process arguments, shell history, environment capture, local configuration files, logs, or compromised dependencies. ### Attack Path 1. The Agent requests or accepts a GitHub credential or obtains a Vercel API token. 2. The user supplies a credential with account-wide or otherwise excessive permissions. 3. The Agent uses the credential through a CLI or browser session to create and deploy the project. 4. The credential rema ...[truncated 727 chars]
Remediation
## Remediation Suggestions - Never request or accept account passwords. - Prefer user-controlled GitHub App installation, OAuth authorization, or repository-specific deploy keys over personal account credentials. - Use short-lived, project-scoped Vercel tokens or user-driven repository integration. - Specify the exact permissions required and reject credentials with unnecessary administrative or account-wide access. - Keep credentials out of chat messages, source files, `LAUNCH-LOG.md`, shell command arguments, and persistent CLI configuration. - Store temporary tokens in a protected secret store and remove local credential state after deployment. - Require explicit user confirmation before operations that create, delete, publish, or alter production resources. - Revoke temporary credentials immediately after setup and document the revocation process. - Audit GitHub and Vercel access logs after deployment and rotate any credential whose handling cannot be verified.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:67
Finding
Unpinned Third-Party CLI Execution Creates a Supply-Chain Risk## Vulnerability Details **File Location**: `SKILL.md`, lines 67-68 **Vulnerability Type**: T08: Insecure Dependencies **Risk Level**: Medium **Vulnerable Code Snippet**: ```markdown * **Tooling:** `write`, `edit` (for creating/modifying code files), `exec` (for `npx create-next-app`, `supabase cli`, `git add/commit`). * **Output:** All project code files committed to the GitHub repository. ``` ### Technical Analysis The Skill authorizes execution of `npx create-next-app` and a Supabase CLI without specifying exact package versions, lockfiles, registry restrictions, provenance verification, checksums, or an isolated execution environment. In particular, `npx` can retrieve and immediately execute package code from a configured package registry. Consequently, the effective executable can change after the Skill has been reviewed. A compromised upstream release, registry account, package-resolution configuration, or maliciously substituted package can execute code with the Agent's local privileges. The risk becomes more severe when deployment, GitHub, Vercel, Supabase, or Stripe credentials are available in the same environment. ### Attack Path 1. The Agent invokes the unpinned `npx create-next-app` command or another unspecified CLI. 2. The package manager resolves the current package version from its configured registry. 3. A compromised, substituted, or unexpectedly modified release is downloaded. 4. Package lifecycle logic or CLI code executes locally with the Agent's permissions. 5. Malicious code reads project files or available credentials, modifies generated source, or inserts code that is subsequently committed and deployed. ### Impact Assessment Exploitation can provide arbitrary code execution under the Agent's operating-system account. The accessible scope may include the entire project workspace, Git credentials, deployment tokens, environment variables, generated source code, and other files rea ...[truncated 144 chars]
Remediation
## Remediation Suggestions - Pin every executable package and CLI to an exact, reviewed version. - Use a committed lockfile and enforce reproducible, frozen dependency installation. - Restrict package resolution to an approved registry and verify package names, publishers, integrity hashes, signatures, and provenance where available. - Avoid automatic execution of packages that are absent from the local dependency set. - Disable unnecessary package lifecycle scripts and review required scripts before execution. - Run scaffolding and installation inside a sandbox or disposable container without production secrets or broad host access. - Perform dependency, malware, and generated-code scans before committing or deploying the result. - Separate dependency installation from credentialed deployment so third-party installation code cannot access GitHub, Stripe, Supabase, or Vercel secrets.
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • 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)

Rp1

Medium
Category
MCP Rug Pull
Confidence
92% confidence
Finding
The skill instructs use of `npx create-next-app` without pinning a specific version, which makes execution dependent on whatever package version is current at runtime. In an autonomous workflow that also uses `exec`, this creates a supply-chain risk: unexpected upstream changes or a compromised package release could alter generated code or execute unintended behavior.

Missing User Warnings

Medium
Confidence
89% confidence
Finding
The skill directs the agent to collect waitlist emails and set up automated customer support, but it provides no requirement to disclose data collection, retention, sharing, or consent to end users. In context, this is more dangerous because the workflow is explicitly public-facing and autonomous, so it could begin collecting personal data and message contents at launch without any privacy notice or governance.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
The skill authorizes ongoing access to Stripe revenue data and product analytics, and instructs logging/reporting of those outputs, but does not warn that sensitive financial and usage data will be accessed, retained, and potentially written into logs. Because the skill also mandates detailed action logging, it increases the chance of exposing business-sensitive metrics or customer-linked telemetry beyond what is necessary.