Back to skill

Security audit

qpcr-primer-designer

Security checks for vulnerabilities and agentic risk

Overview

This skill is a coherent RT-qPCR primer design helper; its main issue is an unpinned Python dependency, not hidden or malicious behavior.

Reasonable to install for primer design if you are comfortable with it contacting NCBI for accession-based lookups. For stronger supply-chain hygiene, pin requests to a reviewed version or use a lock file before installing in sensitive environments.

Vulnerability Patterns
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (1)

T08 · Insecure Dependencies

Note
Location
requirements.txt:1
Finding
Unpinned Third-Party Dependency## Vulnerability Details **File Location**: `requirements.txt:1` **Vulnerability Type**: Unpinned third-party dependency **Risk Level**: Low ### Vulnerable Code ```text requests ``` ### Technical Analysis The project declares the `requests` package without an exact version or an integrity hash. Consequently, separate installations may resolve to different releases. If a future release or the configured package repository is compromised, installation could introduce attacker-controlled code into the environment. This finding concerns supply-chain hardening. The audited package name is legitimate, and the audit found no evidence that the current dependency is malicious. ### Attack Path 1. An attacker compromises the dependency's release process, a package repository, or the dependency-resolution path used by a victim. 2. The attacker publishes or serves a malicious version of `requests`. 3. A user installs the project dependencies from the unpinned `requirements.txt`. 4. The package manager resolves the attacker-controlled version because no exact version or hash is required. 5. Malicious package code executes during installation or when the application imports or uses the dependency. ### Impact Assessment Successful exploitation could execute arbitrary code with the privileges of the user or automation account installing or running the project. The resulting scope could include access to that account's files, environment variables, network permissions, and application data. This project does not itself request elevated privileges, so exploitation would not inherently grant administrative access.
Remediation
## Remediation Suggestions 1. Pin `requests` to an explicitly reviewed version: ```text requests==<reviewed-version> ``` 2. Generate and commit a lock file containing exact transitive dependency versions. 3. Record package hashes and enforce hash verification during installation, such as with pip's `--require-hashes` option. 4. Obtain packages only from a trusted, explicitly configured repository. 5. Integrate dependency vulnerability and update monitoring into CI. 6. Review and deliberately update the pinned version on a regular schedule rather than accepting releases automatically.
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (2)

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests
Confidence
98% confidence
Finding
The dependency is specified as just `requests` with no version pin, which makes builds non-reproducible and can pull in different versions over time, including vulnerable or breaking releases. In a security review context, this is a real supply-chain weakness because the manifest provides no assurance about which code will actually be installed.

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
95% confidence
Finding
`requests` has multiple known advisories, and because no version is pinned, it is impossible to determine whether installation will resolve to a fixed or vulnerable release. The danger is not that the package name itself is malicious, but that the unconstrained dependency leaves the project exposed to potentially affected versions and undermines vulnerability verification.

Static analysis

No suspicious patterns detected.