Back to skill

Security audit

homes-fpx

Security checks for vulnerabilities and agentic risk

Overview

The skill is mostly purpose-aligned, but it needs review because it uses a persistent authenticated browser bridge and includes recipes that can pull personal saved-home data into predictable temporary files.

Install only if you are comfortable letting fpx use your signed-in Homes.com browser session. Use a dedicated browser profile when practical, pin and verify npm package versions, and avoid running the saved-homes or saved-searches recipes unless you specifically need them. Replace the fixed /tmp paths with a private mktemp directory and delete downloaded authenticated pages after parsing.

Vulnerability Patterns
  • 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
  • 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)

T08 · Insecure Dependencies

Warning
Location
SKILL.md:33
Finding
Unpinned npm Dependencies Introduce Supply-Chain Risk<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:33-37`; related recommendations at `references/homes-requests.md:163` and `references/homes-requests.md:256` **Vulnerability Type**: Unpinned third-party package installation **Risk Level**: Medium ### Vulnerable Code ```sh npm install -g @fetchproxy/cli # provides `fpx` fpx profile add homes --domain homes.com fpx pair -p homes # prints a pair code → approve in Transporter ``` The reference documentation additionally recommends an unpinned parser dependency: ```text npm install node-html-parser ``` ### Technical Analysis The setup instructions install the latest package version resolved by the npm registry rather than a reviewed, immutable version. The primary dependency is installed globally, potentially running npm lifecycle scripts with the invoking user's permissions and placing executable files in a global command path. Because neither an exact version nor an integrity-controlled lockfile is specified, the code ultimately installed can change after this Skill has been audited. This creates exposure to package-account compromise, malicious future releases, dependency confusion within transitive dependencies, and registry compromise. The globally installed `fpx` executable is especially security-sensitive because it is subsequently paired with a browser extension and used to send requests through an authenticated browser tab. ### Attack Path 1. An attacker compromises the maintainer account, release pipeline, or a transitive dependency associated with `@fetchproxy/cli` or `node-html-parser`. 2. The attacker publishes a malicious package version that includes an install-time lifecycle script or modified runtime behavior. 3. A user follows the Skill instructions and runs the unpinned `npm install` command. 4. npm resolves and installs the malicious release. 5. Malicious lifecycle code executes with the user's local privileges, or the modified `fpx` executable gai ...[truncated 670 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin each dependency to an exact, reviewed version, for example: ```sh npm install --global --ignore-scripts @fetchproxy/cli@<reviewed-version> ``` Only use `--ignore-scripts` after confirming the package does not legitimately require installation scripts. 2. Document the expected package publisher, registry, version, and package integrity hash. 3. Prefer a project-local installation with a committed lockfile over a global installation: ```sh npm install --save-exact @fetchproxy/cli@<reviewed-version> npm ci npx fpx ... ``` 4. Pin `node-html-parser` to a reviewed exact version and include it in the same lockfile rather than asking users to install the current latest release. 5. Audit transitive dependencies and npm lifecycle scripts before updating pinned versions. 6. Run the CLI under a dedicated, minimally privileged OS and browser profile when practical. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
references/homes-requests.md:10
Finding
Predictable Shared Temporary Files Permit Data Exposure and Local File-Clobbering Attacks<![CDATA[ ## Vulnerability Details **File Location**: `references/homes-requests.md:10-34`; authenticated response examples at `references/homes-requests.md:313-329` **Vulnerability Type**: Unsafe temporary-file handling **Risk Level**: Medium ### Vulnerable Code ```sh cat > /tmp/homes-jsonld.js <<'EOF' // Usage: node /tmp/homes-jsonld.js <html-file> // Prints the parsed JSON-LD document (the `{ "@context", "@graph" }` // envelope, or a synthetic one-element graph if the page emits a bare // root node) as JSON to stdout. const fs = require('fs'); const html = fs.readFileSync(process.argv[2], 'utf8'); // homes.com HTML-entity-encodes the `+` in the script `type` attribute // (`application/ld&#x2B;json`) — match both forms. const m = html.match(/<script type="application\/ld(?:\+|&#x2B;)json">([\s\S]*?)<\/script>/); if (!m) { console.error('no JSON-LD block found'); process.exit(1); } const doc = JSON.parse(m[1].trim()); if (!doc['@graph'] && doc['@type']) { console.log(JSON.stringify({ '@context': doc['@context'], '@graph': [doc] })); } else { console.log(JSON.stringify(doc)); } EOF ``` ```sh # fetch + extract in one step fetch_jsonld() { # $1 = full URL fpx get "$1" -p homes > /tmp/homes-page.html node /tmp/homes-jsonld.js /tmp/homes-page.html } ``` Authenticated pages are also written to fixed paths: ```sh fpx get 'https://www.homes.com/customer/dashboard/favorites/' -p homes > /tmp/saved.html fpx get 'https://www.homes.com/customer/dashboard/saved-searches/' -p homes > /tmp/searches.html ``` ### Technical Analysis The recipes repeatedly use fixed, globally predictable names under `/tmp`, including: - `/tmp/homes-jsonld.js` - `/tmp/homes-page.html` - `/tmp/body.json` - `/tmp/jsonld.json` - `/tmp/saved.html` - `/tmp/searches.html` The files are created or overwritten using ordinary shell redirection without a securely created private directory, restrictive permissions, exclusive creation, symlink checks, or cleanup. On a shared system, another l ...[truncated 2788 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create a unique private directory with `mktemp` and enforce restrictive permissions: ```sh umask 077 tmpdir="$(mktemp -d "${TMPDIR:-/tmp}/homes-fpx.XXXXXX")" || exit 1 trap 'rm -rf -- "$tmpdir"' EXIT HUP INT TERM ``` 2. Store every helper and response beneath that directory: ```sh helper="$tmpdir/homes-jsonld.js" page="$tmpdir/homes-page.html" saved="$tmpdir/saved.html" searches="$tmpdir/searches.html" ``` 3. Quote all generated paths and avoid reopening files through predictable public names. 4. Create sensitive files with mode `0600` and do not rely on the user's ambient `umask`. 5. Remove authenticated response bodies immediately after parsing when retention is unnecessary. 6. Prefer pipes for data that does not need to be retained, while preserving proper pipeline error handling. 7. If a temporary executable helper is unavoidable, create it once inside the private directory, verify its ownership and regular-file status, and execute it through an already-open descriptor or otherwise prevent replacement before invocation. 8. Warn users that saved-home and saved-search responses contain account-specific information and should not be retained in shared storage. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • 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
Findings (1)

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill explicitly documents how to access a signed-in user's saved homes and saved searches through their browser session, but it does not include a clear warning that this touches personal account data or require explicit user consent before use. In this context, the omission is dangerous because the skill is designed to operate via the user's authenticated browser tab, making unauthorized or surprising collection of private preference/history data more likely.

Static analysis

No suspicious patterns detected.