Back to skill

Security audit

Paper Impact Analyzer

Security checks for vulnerabilities and agentic risk

Overview

This skill does what it advertises, but it asks for broader local tool access than it needs and handles external web requests insecurely.

Review before installing. Use it only if you are comfortable sending analyzed paper IDs, titles, repository search terms, and first-author names to external academic and GitHub APIs. Prefer running it in a sandbox without access to sensitive files until the publisher removes unnecessary Read/Write authority, uses HTTPS for arXiv, restores normal TLS verification, and documents the third-party data flows clearly.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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 (3)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/analyze.py:30
Finding

TLS Certificate and Hostname Verification Disabled

Content
View full analysis
str: """Make GET request with timeout and SSL bypass. Returns response body.""" hdrs = {"User-Agent": "PaperImpactAnalyzer/1.0"} if headers: hdrs.update(headers) req = urllib.request.Request(url, headers=hdrs) resp = urllib.request.urlopen(req, timeout=timeout, context=SSL_CTX) return resp.read().decode("utf-8") ``` ### Technical Analysis The code explicitly disables both certificate-chain validation and hostname verification. Consequently, HTTPS connections to GitHub, OpenAlex, and Semantic Scholar do not authenticate the remote endpoint. An attacker capable of intercepting network traffic can present an arbitrary TLS certificate, impersonate the intended API, and return attacker-controlled JSON. The forged response can manipulate repository statistics, citation counts, author information, and URLs included in generated Markdown reports. This issue compromises transport authenticity and response integrity. It does not directly grant local code execution or filesystem access because retrieved data is parsed as XML or JSON rather than executed. ### Attack Path 1. A user invokes the analyzer with an arXiv identifier. 2. The analyzer initiates an HTTPS connection to GitHub, OpenAlex, or Semantic Scholar using the insecure SSL context. 3. An attacker controlling a network gateway, proxy, DNS path, or similar interception point redirects or intercepts the request. 4. The attacker presents an un ...[truncated 695 chars]
Remediation
View remediation

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/analyze.py:113
Finding

arXiv Metadata Retrieved over Unencrypted HTTP

Content
View full analysis
Tuple[PaperImpact, SourceStatus]: """Fetch paper metadata from arXiv API.""" paper = PaperImpact(arxiv_id=arxiv_id) status = SourceStatus(name="arXiv", success=False) try: url = f"http://export.arxiv.org/api/query?id_list={arxiv_id}" xml_text = http_get(url, timeout=15) ``` ### Technical Analysis The primary paper metadata request uses plaintext HTTP. HTTP provides neither confidentiality nor server authentication, allowing an on-path attacker to observe or modify the returned XML. The response supplies the paper title, authors, abstract, comments, publication date, venue information, and GitHub URL used by later analysis stages. In particular, the analyzer extracts a GitHub repository path from the untrusted arXiv abstract or comment and subsequently queries repository statistics for that path. A modified response can therefore influence both the displayed metadata and downstream repository selection. The XML parser does not execute returned content, so this finding does not establish direct local code execution. The principal risk is report manipulation and redirection to attacker-selected content. ### Attack Path 1. A user invokes the analyzer for a legitimate arXiv identifier. 2. The application requests metadata from `export.arxiv.org` over plaintext HTTP. 3. An on-path attacker intercepts the request or response. 4. The attacker replaces the XML response with syntactically valid but modified metadata. 5. The altered response supplies a false title, venue claim, abstract, comment, or GitHub repository URL. 6. The analyzer accepts the response, queries the attacker-selected GitHub reposito ...[truncated 640 chars]
Remediation
View remediation

T05 · Unauthorized Access and Privilege Escalation

Note
Location
SKILL.md:6
Finding

Skill Declares Unnecessary Filesystem Read and Write Capabilities

Content
View full analysis
Remediation
View remediation
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
Findings (17)

Lp1

High
Category
MCP Least Privilege
Confidence
98% confidence
Finding

The script performs multiple outbound network requests to arXiv, GitHub, OpenAlex, and Semantic Scholar, but the finding indicates those capabilities are not declared in the skill’s permissions model. Undeclared network access is a real security issue because it prevents users and the platform from understanding what external data flows occur, undermining consent, sandboxing, and policy enforcement.

Content

No source excerpt is available for this finding.

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
99% confidence
Finding

The global SSL context disables both certificate validation and hostname verification for every HTTPS request. This makes all API traffic vulnerable to man-in-the-middle interception or tampering, allowing an attacker on the network path to forge responses, alter analysis results, or capture transmitted query data.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The HTTP helper is used to send arXiv IDs, title-derived repository search terms, DOI-based lookups, and first-author names to external services without any user-facing disclosure or consent step. Even though the data is academic rather than obviously secret, it can still reveal user interests, research topics, and associated identities to third-party APIs.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
90% confidence
Finding

This GitHub search request transmits title-derived keywords from the analyzed paper to a third party. In context, that is expected functionality, but it is still an external data transfer that can expose a user’s research interests and should be treated as a privacy/security-relevant behavior, especially because TLS verification is globally disabled elsewhere in the file.

Content

Scanner excerpt · scripts/analyze.py (reported line 215)May include surrounding context.

python
words = [w for w in paper.title.split()
                     if len(w) > 2 and w.isalpha() and w.lower() not in stop_words][:5]
            query = "+".join(words)
            url = f"https://api.github.com/search/repositories?q={query}&sort=stars&per_page=5"
            data = http_get_json(url, timeout=10)
            items = data.get("items", [])
            for top in items:

External Transmission

Medium
Category
Data Exfiltration
Confidence
84% confidence
Finding

This request fetches metadata for a specific GitHub repository path, which is less sensitive than free-form search but still constitutes outbound communication to a third party. The main risk is privacy/telemetry exposure and integrity loss from the insecure TLS configuration, rather than arbitrary code execution or direct data exfiltration of secrets.

Content

Scanner excerpt · scripts/analyze.py (reported line 236)May include surrounding context.

python
# Fetch repo details
    try:
        url = f"https://api.github.com/repos/{repo_path}"
        data = http_get_json(url, timeout=10)
        paper.github_stars = data.get("stargazers_count", -1)
        paper.github_forks = data.get("forks_count", -1)

External Transmission

Medium
Category
Data Exfiltration
Confidence
88% confidence
Finding

The OpenAlex request transmits a DOI derived from the user-supplied arXiv identifier to an external service. This is functionally aligned with the skill’s purpose, but it still creates a third-party data flow and can be monitored or modified if TLS verification remains disabled.

Content

Scanner excerpt · scripts/analyze.py (reported line 262)May include surrounding context.

python
status = SourceStatus(name="OpenAlex", success=False)
    try:
        doi = f"10.48550/arXiv.{paper.arxiv_id}"
        url = f"https://api.openalex.org/works/doi:{doi}?select=id,cited_by_count,publication_date"
        data = http_get_json(url, timeout=10, headers={"User-Agent": "mailto:paper-impact@example.com"})
        paper.openalex_citations = data.get("cited_by_count", -1)
        status.success = True

External Transmission

Medium
Category
Data Exfiltration
Confidence
89% confidence
Finding

This Semantic Scholar paper lookup sends the queried arXiv ID to an external API. While expected for citation enrichment, it still reveals the paper being analyzed to a third party and, combined with disabled TLS verification, increases the risk of interception or manipulated response data affecting the report.

Content

Scanner excerpt · scripts/analyze.py (reported line 285)May include surrounding context.

python
try:
        time.sleep(1)  # Rate limit courtesy
        url = (
            f"https://api.semanticscholar.org/graph/v1/paper/ArXiv:{paper.arxiv_id}"
            f"?fields=citationCount,influentialCitationCount"
        )
        data = http_get_json(url, timeout=10)

External Transmission

Medium
Category
Data Exfiltration
Confidence
95% confidence
Finding

This author search sends the first author’s name to Semantic Scholar, which is a stronger privacy signal than sending only an arXiv ID because it discloses a personally identifying research association to a third party. In this skill context it is relevant to functionality, but it should still be treated as sensitive external transmission and is made more dangerous by the global TLS bypass.

Content

Scanner excerpt · scripts/analyze.py (reported line 308)May include surrounding context.

python
time.sleep(1)
            author_name = paper.authors[0].replace(" ", "+")
            url = (
                f"https://api.semanticscholar.org/graph/v1/author/search"
                f"?query={author_name}&fields=name,hIndex,citationCount&limit=3"
            )
            data = http_get_json(url, timeout=10)

Context-Inappropriate Capability

Medium
Category
Not specified by scanner
Confidence
99% confidence
Finding

The script globally disables TLS certificate validation by setting check_hostname=False and verify_mode=CERT_NONE, which makes all HTTPS requests vulnerable to man-in-the-middle interception and response tampering. Because the tool relies on multiple external APIs to produce its report, an attacker on the network path could spoof API responses, manipulate analysis results, or harvest transmitted query data without detection.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
88% confidence
Finding

This GitHub search request transmits title-derived keywords to an external service, disclosing user query context and paper metadata to GitHub. In this skill, the transmission is functionally necessary for finding related repositories, but it still creates a privacy boundary crossing and becomes more dangerous because TLS validation is disabled elsewhere in the script.

Content

Scanner excerpt · skills/paper-impact-analyzer/scripts/analyze.py (reported line 215)May include surrounding context.

python
words = [w for w in paper.title.split()
                     if len(w) > 2 and w.isalpha() and w.lower() not in stop_words][:5]
            query = "+".join(words)
            url = f"https://api.github.com/search/repositories?q={query}&sort=stars&per_page=5"
            data = http_get_json(url, timeout=10)
            items = data.get("items", [])
            for top in items:

External Transmission

Medium
Category
Data Exfiltration
Confidence
85% confidence
Finding

This request fetches repository details from the GitHub API for a discovered repo path, which is an external transmission to a third party. The data sent is limited compared with the search step, but it still leaks the repository of interest and inherits the interception/tampering risk introduced by disabled TLS verification.

Content

Scanner excerpt · skills/paper-impact-analyzer/scripts/analyze.py (reported line 236)May include surrounding context.

python
# Fetch repo details
    try:
        url = f"https://api.github.com/repos/{repo_path}"
        data = http_get_json(url, timeout=10)
        paper.github_stars = data.get("stargazers_count", -1)
        paper.github_forks = data.get("forks_count", -1)

External Transmission

Medium
Category
Data Exfiltration
Confidence
90% confidence
Finding

The OpenAlex lookup sends the paper's DOI derived from the arXiv ID to an external API, exposing the specific paper being analyzed to a third party. This is aligned with the skill's purpose, but it is still a real data transmission and could be observed or tampered with more easily because the script disables TLS verification globally.

Content

Scanner excerpt · skills/paper-impact-analyzer/scripts/analyze.py (reported line 262)May include surrounding context.

python
status = SourceStatus(name="OpenAlex", success=False)
    try:
        doi = f"10.48550/arXiv.{paper.arxiv_id}"
        url = f"https://api.openalex.org/works/doi:{doi}?select=id,cited_by_count,publication_date"
        data = http_get_json(url, timeout=10, headers={"User-Agent": "mailto:paper-impact@example.com"})
        paper.openalex_citations = data.get("cited_by_count", -1)
        status.success = True

External Transmission

Medium
Category
Data Exfiltration
Confidence
90% confidence
Finding

This Semantic Scholar request transmits the analyzed arXiv identifier to a third party to retrieve citation metrics. The behavior is expected for the feature set, but it is still an external disclosure of user interest and is susceptible to response spoofing or observation due to the script's insecure TLS configuration.

Content

Scanner excerpt · skills/paper-impact-analyzer/scripts/analyze.py (reported line 285)May include surrounding context.

python
try:
        time.sleep(1)  # Rate limit courtesy
        url = (
            f"https://api.semanticscholar.org/graph/v1/paper/ArXiv:{paper.arxiv_id}"
            f"?fields=citationCount,influentialCitationCount"
        )
        data = http_get_json(url, timeout=10)

External Transmission

Medium
Category
Data Exfiltration
Confidence
94% confidence
Finding

The author search sends the first author's name to Semantic Scholar, which is personally identifying information and expands the privacy footprint beyond paper metadata alone. In context this is used to estimate h-index, but it should be treated as a meaningful external transmission, especially since insecure TLS handling increases the chance of interception or manipulation.

Content

Scanner excerpt · skills/paper-impact-analyzer/scripts/analyze.py (reported line 308)May include surrounding context.

python
time.sleep(1)
            author_name = paper.authors[0].replace(" ", "+")
            url = (
                f"https://api.semanticscholar.org/graph/v1/author/search"
                f"?query={author_name}&fields=name,hIndex,citationCount&limit=3"
            )
            data = http_get_json(url, timeout=10)

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
94% confidence
Finding

The main execution path automatically sends user-supplied arXiv IDs, derived paper titles, repository search terms, and first-author names to third-party services without any notice or consent prompt. While this is core functionality rather than covert exfiltration, the lack of disclosure creates a privacy and compliance risk because users may not expect their queries and associated metadata to be transmitted to GitHub, OpenAlex, Semantic Scholar, and arXiv.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
91% confidence
Finding

The README explicitly states that the tool queries several third-party APIs using paper identifiers, titles, abstracts, comments, and GitHub search terms, but it does not warn users that these inputs and derived metadata will be transmitted off-platform. While the data is usually public academic metadata, users may still assume analysis is local-only; in some environments this can create privacy, compliance, or data-handling issues.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
89% confidence
Finding

The README explicitly describes sending paper-derived metadata to several third-party APIs but does not warn users that titles, author names, abstracts, comments, DOI/arXiv identifiers, and possibly inferred GitHub queries may be transmitted off-platform. While the data is usually public academic metadata, the lack of disclosure can still create privacy, compliance, and user-expectation issues, especially in enterprise or sensitive research environments where queried papers may reveal interests or internal evaluation activity.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.