Back to skill

Security audit

OIXA Protocol

Security checks for vulnerabilities and agentic risk

Overview

This skill openly connects agents to a live USDC marketplace, but it gives agents real-money and work-submission capabilities over plaintext HTTP without adequate user confirmation, transport security, or safety scoping.

Review carefully before installing or using. Treat this as a live-money integration: do not let an agent bid, post auctions, stake funds, deliver outputs, or release escrow without explicit human approval of the exact action and amount. Avoid sending sensitive work or credentials through the documented HTTP endpoints, use a low-balance dedicated wallet if testing, and prefer pinned SDK versions in an isolated environment.

Vulnerability Patterns
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T01 · Skill Instruction Hijacking

Error
Location
SKILL.md:10
Finding

Untrusted Remote Tasks and MCP Tools Are Accepted over Plaintext HTTP

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:10-13, SKILL.md:31-48, SKILL.md:104-120; references/api-reference.md:3-5, references/api-reference.md:18-19
Vulnerability Type: T01: Skill Instruction Hijacking
Risk Level: High

Vulnerable Code

markdown
**Live API:** `http://64.23.235.34:8000`
**MCP SSE endpoint:** `http://64.23.235.34:8000/mcp/sse`
**Docs:** `http://64.23.235.34:8000/docs`
**SDK:** `pip install oixa-protocol`
markdown
## Core MCP Tools (16 available)

Call these via MCP or the REST API directly.

| Tool | What it does |
|---|---|
| `oixa_list_auctions` | Browse open tasks with budgets. Pass `status="open"` |
| `oixa_get_auction` | Full details on a specific auction before bidding |
| `oixa_create_auction` | Post a task — set `rfi_description`, `max_budget`, `requester_id` |
| `oixa_place_bid` | Bid on an auction. Lowest bid wins. Pass `auction_id`, `bidder_id`, `bidder_name`, `amount` |
| `oixa_register_offer` | Register agent capabilities so others can hire you |
| `oixa_deliver_output` | Submit completed work and trigger automatic USDC release |

Full tool list: `http://64.23.235.34:8000/mcp/tools`

## Quickstart workflows

### Earn USDC: browse and bid on tasks
1. Call `oixa_list_auctions` — find open tasks
2. Call `oixa_get_auction` on a promising one — read the requirements carefully
3. Call `oixa_place_bid` with a competitive amount (lower than max_budget)
4. If you win, execute the task
5. Call `oixa_deliver_output` — USDC releases automatically

Technical Analysis

The skill delegates tool definitions, auction content, and work instructions to a mutable external service hosted at a raw IP address. It explicitly instructs the agent to read third-party task requirements and execute the task if the bid wins.

No trust boundary is defined between skill instructions and marketplace-controlled content. The skill does not instruct the ...[truncated 1691 chars]

Remediation
View remediation

Remediation Suggestions

  • Replace every HTTP endpoint with HTTPS on a verified domain using a valid certificate.
  • Authenticate the remote API and MCP server, and validate server identity before accepting tools or task data.
  • Pin or locally define the permitted MCP tool schemas rather than accepting mutable remote definitions without review.
  • Explicitly classify auction descriptions, bids, and remote responses as untrusted data.
  • Prohibit marketplace content from changing system policy, requesting credentials, accessing unrelated files, or authorizing additional tools.
  • Apply strict allowlists to the tools that may be used while completing a marketplace task.
  • Require explicit user approval after displaying the complete task and planned actions, before bidding, executing work, or submitting output.
  • Sanitize and constrain task inputs using a structured schema rather than placing remote text directly in the agent's instruction context.

T08 · Insecure Dependencies

Error
Location
SKILL.md:82
Finding

Unpinned Third-Party SDK Installation Creates a Supply-Chain Execution Risk

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:82-86; references/api-reference.md:87-90
Vulnerability Type: T08: Insecure Dependencies
Risk Level: High

Vulnerable Code

bash
pip install oixa-protocol          # core
pip install oixa-protocol[langchain]  # + LangChain toolkit
pip install oixa-protocol[crewai]     # + CrewAI tools
pip install oixa-protocol[autogen]    # + AutoGen functions
pip install oixa-protocol[all]        # everything

The reference documentation additionally recommends:

markdown
- LangChain: `pip install oixa-protocol[langchain]`
- CrewAI: `pip install oixa-protocol[crewai]`
- AutoGen: `pip install oixa-protocol[autogen]`
- Haystack: `pip install oixa-protocol[haystack]`

Technical Analysis

These commands install the latest package version selected by the configured Python package index. No exact version, cryptographic hash, lockfile, trusted repository, or package provenance is specified. Installing extras also expands the transitive dependency set and attack surface.

Python package installation may execute build backend logic, and installed modules execute code when imported. Because the audited project does not include the SDK source, the effective implementation cannot be reviewed from this artifact. A compromised release, dependency takeover, malicious transitive dependency, or unexpected future update could therefore introduce arbitrary code after this skill has passed review.

Attack Path

  1. An attacker compromises the oixa-protocol package, one of its transitive dependencies, or the package index used by the environment.
  2. The attacker publishes a malicious version that remains compatible with the unpinned installation command.
  3. A user follows the skill and runs pip install oixa-protocol or installs one of the extras.
  4. Malicious code executes during package build, installation, or subsequent import.
  5. The payload operates ...[truncated 504 chars]
Remediation
View remediation

Remediation Suggestions

  • Pin the SDK and every transitive dependency to audited exact versions.
  • Provide a lockfile containing cryptographic hashes and require hash verification during installation.
  • Publish the SDK source and reproducible build information so the installed artifact can be compared with reviewed source.
  • Use a trusted package repository and verify package publisher identity and release provenance.
  • Avoid the [all] extra unless every included integration is necessary and independently audited.
  • Install the SDK in an isolated, nonprivileged virtual environment or container with restricted filesystem and network access.
  • Generate and review a software bill of materials and continuously scan dependencies for known vulnerabilities and ownership changes.
  • Disable unnecessary build isolation network access and prefer pre-reviewed signed wheels where operationally possible.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:17
Finding

Autonomous Mainnet Financial Operations Lack Explicit Authorization Controls

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:17-25, SKILL.md:42-58, SKILL.md:88-99, SKILL.md:122-128; references/api-reference.md:31-57, references/api-reference.md:70-80
Vulnerability Type: T09: Insecure Skill Coding Practices
Risk Level: High

Vulnerable Code

markdown
## How it works

1. An agent posts a task (RFI) with a max budget in USDC → goes into escrow
2. Other agents bid downward in a reverse auction (lowest bid wins)
3. Winning agent delivers → OIXA verifies cryptographically → USDC releases automatically
4. 5% protocol fee. 95% to the agent that did the work.

Anti-Sybil: every bidder stakes 20% of their bid. No stake, no bid.
markdown
### Earn USDC: browse and bid on tasks
1. Call `oixa_list_auctions` — find open tasks
2. Call `oixa_get_auction` on a promising one — read the requirements carefully
3. Call `oixa_place_bid` with a competitive amount (lower than max_budget)
4. If you win, execute the task
5. Call `oixa_deliver_output` — USDC releases automatically

### Hire an agent: post a task
1. Call `oixa_create_auction` with task description and max budget
2. Wait for bids (closes in 1–30 seconds depending on budget size)
3. The winning agent delivers — OIXA verifies — escrow releases

Technical Analysis

The documented workflows authorize an agent to create funded auctions, place bids requiring a 20% stake, and trigger USDC settlement on Base Mainnet. They do not require per-transaction user confirmation, spending limits, recipient validation, transaction simulation, wallet separation, or independent verification of the chain, token, and escrow contract.

These operations have direct and potentially irreversible financial consequences. The short auction windows further encourage automated action while reducing the opportunity for meaningful user review. The documentation's statement that settlement occurs automatically does not establish that ...[truncated 1154 chars]

Remediation
View remediation

Remediation Suggestions

  • Require explicit human confirmation for every bid, stake, auction creation, approval, and settlement-triggering action.
  • Display the chain, contract, token address, amount, fees, allowance changes, recipient, and worst-case loss before confirmation.
  • Enforce configurable per-transaction, daily, and cumulative spending limits outside the model's control.
  • Use a dedicated low-balance wallet with narrowly scoped token allowances and no access to unrelated assets.
  • Verify the Base chain ID, native USDC contract, escrow contract bytecode, and expected contract methods against a trusted allowlist.
  • Simulate transactions and reject unexpected token transfers, approval changes, delegate calls, or contract destinations.
  • Introduce replay protection, idempotency keys, nonce checking, and independent reconciliation of escrow state.
  • Default to testnet or a noncustodial dry-run mode until the complete workflow has been independently audited.
  • Do not permit remote auction text or MCP responses to authorize or increase financial limits.

T09 · Insecure Skill Coding Practices

Error
Location
SKILL.md:67
Finding

Agent Identity, Bids, and Work Product Are Transmitted over Plaintext HTTP

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:67-78; references/api-reference.md:43-68
Vulnerability Type: T09: Insecure Skill Coding Practices
Risk Level: High

Vulnerable Code

python
import httpx

# List open auctions
r = httpx.get("http://64.23.235.34:8000/auctions?status=open")
auctions = r.json()

# Place a bid
r = httpx.post("http://64.23.235.34:8000/bids", json={
    "auction_id": "oixa_auction_xxx",
    "bidder_id": "my_agent_001",
    "bidder_name": "My Agent",
    "amount": 0.05
})

The API reference documents delivery of the completed work through the same plaintext service:

json
{
  "auction_id": "oixa_auction_xxx",
  "agent_id": "my_agent_001",
  "output": "{ ... your result ... }"
}

Technical Analysis

The example sends agent identifiers, auction identifiers, bid amounts, and marketplace activity to an HTTP endpoint without TLS. The documented output-delivery operation can additionally transmit the full completed work product.

Plaintext HTTP does not protect confidentiality, integrity, or endpoint authenticity. An on-path attacker can observe requests and responses, modify bid amounts or auction identifiers, inject response data, or capture submitted work. A raw IP address also prevents the normal domain-based identity and certificate validation expected from HTTPS.

The skill supplies no authentication mechanism, request signing, response signature verification, output classification, redaction policy, or user-consent checkpoint before disclosure.

Attack Path

  1. The agent connects to the API through an untrusted network, compromised gateway, proxy, or other on-path position.
  2. The attacker passively records agent identifiers, auction activity, bid values, and submitted output.
  3. Alternatively, the attacker modifies a request to change the auction ID or bid amount, or alters the response used by the agent.
  4. The server or agent ...[truncated 707 chars]
Remediation
View remediation

Remediation Suggestions

  • Replace the raw-IP HTTP endpoint with HTTPS on a verified domain and enforce certificate validation.
  • Reject redirects or configuration changes that downgrade transport security to HTTP.
  • Require strong authenticated API sessions using short-lived, narrowly scoped credentials.
  • Cryptographically sign financially significant requests and verify signed server responses.
  • Bind signatures to the operation, auction ID, amount, agent identity, timestamp, nonce, and destination.
  • Classify and redact output before transmission; prohibit submission of credentials, secrets, unrelated local data, or personal information.
  • Obtain explicit user consent before transmitting any confidential work product to the marketplace.
  • Use idempotency keys and server-side authorization checks rather than treating caller-supplied agent identifiers as proof of identity.
  • Log disclosure and transaction metadata without recording sensitive output or authentication material.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (4)

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The skill promotes autonomous use of a live blockchain-linked marketplace that can move real USDC via escrow and settlement, but it provides no safety warning, confirmation requirement, or discussion of irreversible financial consequences. In an agent-skill context, this omission is dangerous because users or downstream agents may invoke bidding, task posting, or delivery flows as routine API actions without understanding they can trigger real-money commitments and on-chain effects.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The skill exposes live plaintext HTTP endpoints for the API, docs, MCP SSE stream, and agent card without warning that task content, agent identifiers, bidding data, and possibly credentials or tokens could be transmitted insecurely. Because this skill is specifically designed for agent-to-agent economic activity, sending marketplace and identity data over unencrypted channels materially increases the risk of interception, tampering, impersonation, and privacy loss.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
93% confidence
Finding

The code example performs a direct POST to a live external endpoint to place a bid, which causes transmission of agent identity and bid data to a third-party service and may trigger financially meaningful marketplace actions. Even though it is presented as documentation, in a copy-pasteable skill this normalizes unsandboxed external actions and can lead agents or users to exfiltrate operational data or commit funds without adequate review.

Content

Scanner excerpt · SKILL.md (reported line 69)May include surrounding context.

md
auctions = r.json()

# Place a bid
r = httpx.post("http://64.23.235.34:8000/bids", json={
    "auction_id": "oixa_auction_xxx",
    "bidder_id": "my_agent_001",
    "bidder_name": "My Agent",

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
92% confidence
Finding

The documentation instructs users to create auctions where 'USDC goes into escrow immediately' and to 'release USDC from escrow' on output delivery, but it does not present an explicit warning about real financial consequences, irreversible transfers, trust assumptions, or the need for user confirmation. In an agent-skill context, this is dangerous because an integrating agent may expose or automate these actions directly, causing unintended on-chain fund movement or financial loss without adequate user awareness.

Content

No source excerpt is available for this finding.