Back to skill

Security audit

Aerobase Skill

Security checks for vulnerabilities and agentic risk

Overview

This travel skill is a disclosed Aerobase API integration that sends user-provided trip details to Aerobase, with some privacy and dependency hygiene cautions but no evidence of hidden or malicious behavior.

Install only if you are comfortable sending flight searches, itinerary details, and any entered arrival commitments to Aerobase using your API key. Prefer running it with a narrowly scoped key if Aerobase supports that, avoid entering unnecessary sensitive meeting details, and pin or lock Python dependencies before production use.

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
requirements.txt:1
Finding
Unbounded Third-Party Dependency Version<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1` and `README.md:50` **Vulnerability Type**: `T08: Insecure Dependencies` **Risk Level**: Medium ### Vulnerable Code `requirements.txt:1`: ```text requests>=2.31.0 ``` `README.md:50`: ```bash pip install -r requirements.txt ``` ### Technical Analysis The project specifies only a minimum version of `requests`, without an upper bound, exact version, lock file, or package hashes. Consequently, installation can resolve to any future release of `requests` and to mutable versions of its transitive dependencies. This prevents the audited source tree from uniquely determining the code that will be installed. If a future direct or transitive dependency release is compromised, or if dependency resolution is performed against an untrusted package index, malicious package code could run during package build, installation, or subsequent import. No currently malicious package or dependency-confusion name was identified. The issue is the use of an unconstrained and unverifiable dependency resolution process. ### Attack Path 1. An attacker compromises a future release of `requests`, one of its transitive dependencies, or a package index used by the victim. 2. A user follows the documented installation command: ```bash pip install -r requirements.txt ``` 3. Because `requests>=2.31.0` accepts arbitrary later versions and no hashes are enforced, pip resolves and installs the compromised artifact. 4. Malicious code executes during package build or installation, or when `requests` is imported by `tools/aerobase.py`. 5. The code operates with the permissions of the user running pip or the CLI. ### Impact Assessment Successful exploitation could permit arbitrary code execution with the privileges of the installing or executing user. Depending on those privileges, the attacker could access user-readable files, environment variables such as `AEROBASE_API_KEY`, network resources, and writable p ...[truncated 276 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the direct dependency to a reviewed version rather than using a lower-bound-only constraint: ```text requests==<reviewed-version> ``` 2. Generate a lock file containing reviewed versions of all transitive dependencies. 3. Include cryptographic hashes and require their verification during installation: ```bash pip-compile --generate-hashes requirements.in pip install --require-hashes -r requirements.txt ``` 4. Configure installation to use only a trusted package index. 5. Add automated dependency vulnerability and integrity scanning to CI. 6. Establish a controlled update process that reviews and tests dependency changes before modifying the lock file. ]]>

T09 · Insecure Skill Coding Practices

Note
Location
tools/aerobase.py:46
Finding
Outbound HTTP Requests Lack Explicit Timeouts<![CDATA[ ## Vulnerability Details **File Location**: `tools/aerobase.py:46-50, 75-79, 92-96, 116-121, 142-146, 153-157, 164-169, 176-181, 188-193` **Vulnerability Type**: `T09: Insecure Skill Coding Practices` **Risk Level**: Low ### Vulnerable Code ```python response = requests.post( f"{BASE_URL}/v1/flights/search", headers=get_headers(), json=payload, ) ``` ```python response = requests.post( f"{BASE_URL}/v1/flights/score", headers=get_headers(), json=payload, ) ``` ```python response = requests.post( f"{BASE_URL}/v1/flights/compare", headers=get_headers(), json={"flights": flights}, ) ``` ```python response = requests.get( f"{BASE_URL}/v1/deals", headers=get_headers(), params=params, ) ``` ```python response = requests.post( f"{BASE_URL}/v1/recovery/plan", headers=get_headers(), json=payload, ) ``` ```python response = requests.get( f"{BASE_URL}/v1/airports/{code}", headers=get_headers(), ) ``` ```python response = requests.get( f"{BASE_URL}/v1/hotels", headers=get_headers(), params=params, ) ``` ```python response = requests.get( f"{BASE_URL}/v1/lounges", headers=get_headers(), params={"airport": airport, "limit": limit}, ) ``` ```python response = requests.post( f"{BASE_URL}/v1/itinerary/analyze", headers=get_headers(), json={"legs": legs}, ) ``` ### Technical Analysis Every outbound `requests.get` and `requests.post` invocation omits the `timeout` parameter. The Requests library does not impose a request timeout by default. A connection can therefore remain blocked for an indefinite period if the remote endpoint accepts the connection but fails to complete the response. The destination is a fixed HTTPS origin, `https://aerobase.app/api`, which limits direct user-controlled SSRF exposure. Exploitation would generally require failure or compromise of the upstream service, a network-path disruption, or a connection that remains open without re ...[truncated 1142 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Add explicit connect and read timeouts to every HTTP request: ```python response = requests.post( url, headers=get_headers(), json=payload, timeout=(5, 30), ) ``` 2. Centralize HTTP configuration in a `requests.Session` or wrapper so that all endpoints consistently enforce timeouts. 3. Handle timeout failures explicitly: ```python except requests.exceptions.Timeout: print("Error: Aerobase API request timed out", file=sys.stderr) sys.exit(1) ``` 4. Use a limited retry policy only for safe and transient failures. Apply backoff and a strict retry cap to avoid extending denial-of-service conditions. 5. Ensure the calling Agent or process supervisor also enforces an overall execution deadline and terminates stalled child processes. ]]>
Vulnerability Patterns
  • 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
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (15)

Credential Access

High
Category
Privilege Escalation
Content
pip install -r requirements.txt

# Set your API key
cp .env.dist .env
# Edit .env with your API key
```
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
pip install -r requirements.txt

# Set your API key
cp .env.dist .env
# Edit .env with your API key
```
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared description says the skill searches, scores, and compares flights, but the documented behavior also includes recovery plans, travel deals, airport info, hotels, lounges, itinerary analysis, and external API use. This mismatch can mislead users and reviewers about what data is processed and what actions the skill can take, increasing the chance of over-trusting it.

Credential Access

High
Category
Privilege Escalation
Content
def get_api_key() -> str:
    """Get API key from environment or prompt."""
    api_key = os.environ.get("AEROBASE_API_KEY")
    if not api_key:
        print("Error: AEROBASE_API_KEY not set", file=sys.stderr)
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The README says the skill is automatically discovered and invoked and lists multiple API-backed travel tools, but it does not clearly disclose that user itinerary details will be transmitted to the external Aerobase service. In an agent setting, this can cause users or operators to unknowingly send sensitive travel metadata, creating privacy and consent risks.

Lp3

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding
The skill requires environment-variable access and makes authenticated network requests, but it does not declare any explicit tool scope such as permissions or allowed-tools. This weakens sandboxing and user awareness because an agent may be granted broader capabilities than the manifest transparently communicates.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The documentation shows that itinerary, schedule, airport, and possibly meeting/commitment details are sent to an external API, but it does not clearly warn users that this information leaves the local environment. That omission creates a privacy and consent risk, especially because travel schedules and commitments can be sensitive personal or business information.

External Transmission

Medium
Category
Data Exfiltration
Content
**Command:**
```bash
curl -X POST https://aerobase.app/api/v1/flights/search \
  -H "Authorization: Bearer $AEROBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
90% confidence
Finding
This command sends flight search parameters and an API bearer token to an external service. While expected for a flight-search skill, it still creates data exposure and secret-handling risk if users are not informed, if requests are over-broad, or if logs capture request contents.

External Transmission

Medium
Category
Data Exfiltration
Content
**Command:**
```bash
curl -X POST https://aerobase.app/api/v1/flights/score \
  -H "Authorization: Bearer $AEROBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
92% confidence
Finding
This endpoint transmits detailed departure and arrival timestamps, route information, and possibly traveler preferences to a third-party API along with the bearer token. Those details can reveal sensitive travel patterns, and the risk is elevated because the documentation lacks explicit privacy warnings.

External Transmission

Medium
Category
Data Exfiltration
Content
**Command:**
```bash
curl -X POST https://aerobase.app/api/v1/flights/compare \
  -H "Authorization: Bearer $AEROBASE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
Confidence
89% confidence
Finding
The compare-flights command sends multiple candidate itineraries and labels to an external API, which can disclose broader travel planning intent than a single search. Although this is core functionality, it still constitutes third-party transmission of potentially sensitive business or personal travel data.

External Transmission

Medium
Category
Data Exfiltration
Content
**Command:**
```bash
curl "https://aerobase.app/api/v1/airports/JFK" \
  -H "Authorization: Bearer $AEROBASE_API_KEY"
```
Confidence
84% confidence
Finding
These commands fetch airport, hotel, and lounge information from the external provider using the API key. The transmitted data is less sensitive than full itinerary details, but still involves authenticated outbound calls and expands the skill's external-data surface beyond the narrow flight-search description.

Missing User Warnings

Medium
Confidence
88% confidence
Finding
The tool sends user-provided itinerary and travel details to a third-party service, but the code provides no explicit user-facing notice or consent mechanism before transmitting potentially sensitive travel data. In an agent setting, users may reasonably believe inputs are processed locally, so undisclosed sharing increases privacy and data-handling risk.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The manifest description is centered on flight search, scoring, comparison, and jetlag impact analysis. The implementation expands into adjacent travel-concierge capabilities such as travel deals, airport info, hotels, lounges, and recovery plans, which are not clearly disclosed by that description.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
Confidence
94% confidence
Finding
The dependency is specified as `requests>=2.31.0`, which allows any future version to be installed and makes builds non-reproducible. This increases supply-chain risk because a newly published vulnerable or breaking release could be pulled in without review, and it also prevents auditors from knowing exactly which code will run.

Unverifiable Dependency: requests has 16 known advisory(ies) (CVE-2014-1830 (Exposure of Sensitive Information to an Unauthorized Actor in Requests); CVE-2024-47081 (Requests vulnerable to .netrc credentials leak via malicious URLs); CVE-2024-35195 (Requests `Session` object does not verify requests after making first request wi) +13 more), but the manifest does not pin a version, so it is unknown whether the installed release is affected

Low
Category
Supply Chain
Confidence
88% confidence
Finding
`requests` has multiple published advisories, but because the manifest does not pin a specific version, it is impossible to verify whether the installed release is affected. In a flight-search skill that likely performs external HTTP requests, uncertainty around the exact `requests` version is relevant because vulnerable client behavior could expose credentials, weaken TLS/request handling, or leak data in edge cases.