T09 · Insecure Skill Coding Practices
- Location
SKILL.md:24- Finding
Anthropic API Credential Disclosed to a Third-Party Hosted Service
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
This skill appears to do repository issue summarization, but its hosted path asks users to send a reusable Anthropic API key to a third-party gateway without enough handling or retention detail.
Review before installing or using the hosted API. Do not send a production Anthropic API key to the MeshCore endpoint unless you trust that operator and accept the billing and exposure risk; prefer self-hosting with a limited, revocable key. If self-hosting, pin dependencies, run as a low-privilege user, and treat GitHub issue text as untrusted model input.
SKILL.md:24Anthropic API Credential Disclosed to a Third-Party Hosted Service
repo_insights.py:21Indirect Prompt Injection Through Untrusted GitHub Issue Titles
requirements.txt:1Unpinned Runtime Dependencies Permit Unreviewed Package Resolution
The documentation instructs users to send both a repository URL and an Anthropic API key to a hosted third-party endpoint, but it does not clearly warn that these values leave the local environment and are exposed to an external service operator. This can lead to inadvertent credential disclosure and unauthorized use of a user's API key.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
pip install -r requirements.txt
gunicorn repo_insights:app --bind 0.0.0.0:5001
curl -X POST http://localhost:5001/analyze \
-H "Content-Type: application/json" \
-d '{"repo_url": "https://github.com/owner/repo"}'
The manifest advertises only network permission, but the embedded metadata additionally allows local workspace reads and execution of python3 and gunicorn. This creates a capability mismatch that can mislead users and automated policy systems about the true access level of the skill, increasing the risk of unexpected file access or code execution.
The skill is described in broad, open-ended terms without clear constraints on when it should be invoked or what repositories it should analyze. That increases the chance of overbroad routing or unintended use, especially in agent ecosystems where vague descriptions can trigger tools in inappropriate contexts.
The example explicitly POSTs user-supplied data, including an Anthropic API key, to an external endpoint. External transmission is expected for a networked skill, but transmitting raw credentials to a third-party gateway materially increases the security impact because the endpoint can log, retain, or misuse those secrets.
POST request:
curl -X POST https://meshcore.ai/gateway/call/d062a753-f46c-4a48-808c-fa27dad82de3 \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_MESHCORE_API_KEY" \
-d '{"repo_url": "https://github.com/owner/repo", "api_key": "YOUR_ANTHROPIC_KEY"}'
The skill's stated purpose is repository analysis, but it silently requires a caller-supplied Anthropic API key and uses it to make an external LLM request. This creates a security and trust problem because users may provide a sensitive credential to a skill whose manifest does not clearly disclose that it will transmit issue data to Anthropic using the user's key.
The endpoint accepts a raw API key in the request body and immediately uses it for an outbound call to Anthropic, without any visible warning, consent flow, or key-handling safeguards. Even if not logged here, collecting third-party secrets in this way increases the risk of accidental exposure, misuse, and user confusion about where their credential is being sent.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
owner, name = parts[-2], parts[-1]
resp = requests.get(
f"https://api.github.com/repos/{owner}/{name}/issues",
params={"state": "open", "per_page": 10},
timeout=15
).json()
The markdown file tells users to set ANTHROPIC_API_KEY directly but does not include any caution that this is a sensitive secret or guidance to avoid exposing it in shared shells, logs, or screenshots. For markdown files, missing warnings about behaviors affecting privacy or credential safety should be flagged.
The dependency list leaves Flask unpinned, so builds may resolve to different versions over time, including versions with known security defects or breaking changes. In a network-exposed Flask API, this increases supply-chain and patch-management risk because the deployed package version cannot be reliably audited or reproduced.
flask
requests
anthropic
gunicorn
Flask has known advisories, and because no version is pinned, it is impossible to verify from this manifest whether the deployed build is affected. In a web API context, that uncertainty is meaningful because vulnerable framework versions can expose the service to denial-of-service, session, or request-handling issues.
Requests is unpinned, so dependency resolution may install different releases across environments and over time, including releases affected by disclosed vulnerabilities. Because this skill has network permissions and likely performs outbound HTTP requests, using an unverified requests version weakens assurance around transport and credential-handling behavior.
flask
requests
anthropic
gunicorn
Requests has multiple published advisories, but the manifest does not specify a version, so the security posture of the installed library cannot be determined. Given the skill's networked behavior, an affected requests release could influence outbound request security, credential handling, or redirect behavior.
The anthropic SDK is unpinned, which makes the runtime dependency non-reproducible and could pull in a version with security issues or incompatible behavior. Since this service depends on the SDK for external AI calls, uncertainty in the installed version increases operational and potential security risk.
flask
requests
anthropic
gunicorn
The anthropic package has known advisories, and without version pinning there is no way to verify whether deployment uses a fixed or vulnerable release. While the exact exploitability depends on how the SDK is used, unresolved version ambiguity is still a supply-chain risk for this service.
Gunicorn is unpinned, so the production web server version may drift and potentially include vulnerable releases. For an internet-facing Flask API, uncertainty around the exact Gunicorn version matters because server-layer flaws can affect request parsing, smuggling resistance, and availability.
flask
requests
anthropic
gunicorn
Gunicorn has known advisories, and the lack of version pinning prevents verification that the deployed web server includes relevant fixes. Because Gunicorn fronts a network-accessible API, running an affected version could expose request smuggling or denial-of-service weaknesses at the server boundary.