Back to skill

Security audit

生命涌现设备管理

Security checks for vulnerabilities and agentic risk

Overview

This camera-management skill has real device-control functionality, but it under-discloses sensitive account, stream, credential, and face-analysis data handling that users should review before installing.

Install only if you accept that this skill can contact external Life Emergence/Open API services, manage and control registered cameras, expose stream links, create or reuse an account from your OpenClaw identity, and store tokens locally. Treat it as needing review or remediation before normal use: remove or separate the face-analysis component, require explicit consent for account creation and media uploads, avoid HTTP/query-string playback secrets, redact logs, and store credentials in a proper secret store.

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 (7)

T09 · Insecure Skill Coding Practices

Error
Location
skills/smyx_common/scripts/util.py:317
Finding
Authentication Credentials Can Be Forwarded to Arbitrary Absolute URLs<![CDATA[ ## Vulnerability Details **File Location**: `skills/smyx_common/scripts/util.py:317-318, 352-354, 386-387` **Vulnerability Type**: Credential exfiltration through unrestricted request destinations **Risk Level**: High ### Vulnerable Code ```python if not url.startswith("https://") and not url.startswith("http://"): url = cls.BASE_URL + url headers.setdefault("X-Access-Token", ApiEnum.TOKEN) headers.setdefault("X-Api-Key", ApiEnum.API_SECRET_KEY) headers.setdefault("Authorization", ApiEnum.OPEN_TOKEN) response = requests.request( method, url, *args, json=data, params=params, headers=headers, timeout=int(timeout), **argss ) ``` ### Technical Analysis The shared HTTP helper accepts both relative and absolute URLs. Relative paths are appended to the configured service base URL, but absolute HTTP or HTTPS URLs are accepted without validating their hostname, port, or trust level. After destination processing, the helper automatically attaches the current access token, API key, and open authorization token. Consequently, any internal or future caller that passes an attacker-controlled absolute URL can cause authentication credentials to be transmitted to an unrelated server. The credential attachment occurs regardless of whether the destination belongs to the expected `lifeemergence.com` service. HTTPS alone would not resolve the issue because an attacker can operate a valid HTTPS endpoint. ### Attack Path 1. An attacker identifies a call path where a request URL is user-controlled or can be influenced through configuration, plugin code, or a future endpoint integration. 2. The attacker supplies an absolute URL such as `https://attacker.example/collect`. 3. `http_request()` recognizes the string as an absolute URL and does not prepend the trusted API base. 4. The function adds `X-Access-Token`, `X-Api-Key`, and `Authorization`. 5. The request is sent to the attacker-controlled endpoint. 6. The attacker captures ...[truncated 614 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Reject absolute URLs in the authenticated request helper and only accept relative API paths. 2. If absolute URLs are operationally required, parse them with `urllib.parse.urlparse()` and enforce: - HTTPS only; - An exact hostname allowlist; - An approved port list; - No embedded user information; - No redirects to untrusted hosts. 3. Attach authentication headers only after destination validation. 4. Disable automatic redirects or revalidate the destination on every redirect. 5. Use separate unauthenticated and authenticated HTTP clients. 6. Add tests proving that credentials are not sent to unapproved hosts. 7. Rotate existing credentials if logs or untrusted URL calls may already have exposed them. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
skills/smyx_common/scripts/util.py:370
Finding
Raw Authentication Headers Are Exposed in Success and Error Logs<![CDATA[ ## Vulnerability Details **File Location**: `skills/smyx_common/scripts/util.py:370-379, 427-449` **Vulnerability Type**: Sensitive credential disclosure through application logs **Risk Level**: High ### Vulnerable Code ```python safe_headers = {} for k, v in headers.items(): if v is None: safe_headers[k] = "None" elif isinstance(v, (dict, list)): safe_headers[k] = type(v).__name__ elif len(v) > 30: safe_headers[k] = v[:20] + "..." else: safe_headers[k] = v print( f"🔄 请求拦截, URL:{url}", "method", method, "params", params, "data", data, "headers", safe_headers, "options", options, "timeout", timeout ) # ... print( f"✅ 请求拦截, 成功:{response_text}, url:{url}", "method", method, "params", params, "data", data, "headers", headers, "timeout", timeout ) ``` The exception path also logs request context without consistently applying the `safe_headers` redaction object. ### Technical Analysis The pre-request diagnostic creates a partially masked `safe_headers` dictionary. However, the success path prints the original `headers` object, which contains: - `X-Access-Token`; - `X-Api-Key`; - `Authorization`. Therefore, the attempted redaction does not protect credentials after a successful request. The error-handling path similarly risks exposing sensitive request context. In addition, the initial masking still exposes the first 20 characters of long secrets, which is unnecessary and may aid token identification or correlation. Request data and parameters are also logged without field-level filtering, potentially exposing account identifiers, camera serial numbers, connection information, and other sensitive values. ### Attack Path 1. A user performs any operation that invokes the shared request helper, such as listing devices. 2. Authentication tokens are loaded or created and attached to the request headers. 3. The cloud request succeeds or encounters an ...[truncated 712 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove all logging of raw request headers. 2. Replace every sensitive value with a fixed marker such as `[REDACTED]`; do not retain secret prefixes. 3. Apply structured field-level redaction to request parameters and bodies. 4. Treat at least the following as sensitive: - `Authorization`; - `X-Access-Token`; - `X-Api-Key`; - Tokens and connection strings; - Passwords and security codes; - Phone numbers and sender identifiers. 5. Avoid logging complete server responses where they can contain tokens or personal data. 6. Review retained logs and rotate credentials that may have been exposed. 7. Add automated tests that capture output and verify that known secret values never appear. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
skills/smyx_common/scripts/dao.py:62
Finding
Cloud Authentication Tokens Are Stored Unencrypted in a Workspace-Wide SQLite Database<![CDATA[ ## Vulnerability Details **File Location**: `skills/smyx_common/scripts/dao.py:62-79, 325-334` **Vulnerability Type**: Plaintext storage of reusable authentication credentials **Risk Level**: High ### Vulnerable Code ```python workspace = os.environ.get('OPENCLAW_WORKSPACE', workspace) parent_dir = os.path.join(workspace, "data") FileUtil.mkdir(parent_dir) db_path = os.path.join(parent_dir, db_path) # ... if not db_path: db_path = "smyx-common-claw.db" db_path = self.get_db_path(db_path) self.engine = create_engine(f"sqlite:///{db_path}", echo=False) ``` ```python class User(Base, BaseModelMixin): __tablename__ = "sys_user" id = Column(String(32), primary_key=True, index=True) source_id = Column(String(32), comment="source id") username = Column(String(100), unique=True, index=True, nullable=False) email = Column(String(45), unique=True, index=True) # ... token = Column(String(500), comment="token") open_token = Column(String(1000), comment="open token") source = Column(String(50), comment="token") ``` The token population path appears in `skills/smyx_common/scripts/util.py:329-345`, where remotely issued `token` and `openToken` values are copied into the `User` model and saved. ### Technical Analysis Reusable access and open authorization tokens are stored directly in a SQLite database under `${OPENCLAW_WORKSPACE}/data/smyx-common-claw.db`. No application-level encryption, operating-system key store, restrictive file-mode creation, or documented token-at-rest protection is implemented. SQLite does not encrypt column values by default. Anyone able to read the database file or its backups can inspect token values without needing to execute the Skill. The database is shared through a workspace-level data directory rather than isolated to a transient process. This increases exposure to other skills, local processes, backups, support bundles, and users with workspace access. ### Attack Path 1. A l ...[truncated 907 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Store tokens in an operating-system credential manager or dedicated secret service. 2. If database persistence is required, encrypt each token using an authenticated encryption scheme, with the key stored outside the database. 3. Create the database and containing directory with owner-only permissions, such as `0600` for the file and `0700` for the directory. 4. Store short-lived refreshable credentials instead of long-lived bearer tokens where possible. 5. Define token expiration, revocation, logout, and secure deletion behavior. 6. Avoid sharing credentials across unrelated skills. 7. Prevent database files from entering backups, diagnostics, source archives, or synchronization systems unless encrypted. 8. Rotate any tokens that may have been copied from existing databases. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/api_service.py:33
Finding
Camera Playback Tokens and Connection Strings Are Exposed in Plain-HTTP URLs<![CDATA[ ## Vulnerability Details **File Location**: `scripts/api_service.py:33-47` **Vulnerability Type**: Sensitive playback credentials transmitted in an insecure URL **Risk Level**: High ### Vulnerable Code ```python if result: for item in result: camera_sn = item["cameraSn"] camera_type = item["cameraType"] if camera_type == ApiEnum.CameraTypeEnum.TAN_GE.value: camera_device_player_info = await self.get_tange_device_player_info(camera_sn) if camera_device_player_info: import urllib.parse token = urllib.parse.quote( camera_device_player_info.get('token'), safe='' ) device_connection_string = urllib.parse.quote( camera_device_player_info.get('deviceConnectionString'), safe='' ) hls_url = ( f"{ApiEnum.BASE_URL_OPEN_H5}/device-player/" f"?deviceId={camera_sn}" f"&token={token}" f"&deviceConnectionString={device_connection_string}" ) item["hlsUrl"] = hls_url ``` The production destination is configured in `skills/smyx_common/scripts/config.yaml:7-9`: ```yaml base-url-open-api: "https://open.lifeemergence.com/smyx-open-api" base-url-open-h5: "http://livemonitor.lifeemergence.com" base-url-health: "https://lifeemergence.com/jeecg-boot-xzgz" ``` ### Technical Analysis The device-list operation retrieves a playback token and device connection string, embeds both values in URL query parameters, and returns the resulting URL as part of device data. The configured playback origin uses plain HTTP. URL encoding does not provide confidentiality; it only makes characters safe for inclusion in a URL. The resulting secrets may be exposed through: - Network interception or modification; - Browser history; - Proxy and web-server logs; - Referrer header ...[truncated 1095 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require HTTPS for every production web and playback endpoint. 2. Do not put playback tokens or connection strings in query parameters. 3. Exchange credentials server-side for a short-lived, single-purpose playback session. 4. Prefer secure, `HttpOnly`, `Secure`, and appropriately scoped cookies or an authorization header. 5. Bind playback sessions to the intended user, device, audience, and expiration time. 6. Prevent sensitive playback URLs from being printed in logs or retained in transcripts. 7. Set a restrictive `Referrer-Policy`, such as `no-referrer`, on the playback application. 8. Revoke exposed playback tokens and review proxy/web logs for leaked URLs. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
skills/smyx_common/scripts/util.py:296
Finding
Environment-Derived Sender Identifiers Are Silently Used for Remote Account Registration<![CDATA[ ## Vulnerability Details **File Location**: `skills/smyx_common/scripts/util.py:296-341` **Vulnerability Type**: Undisclosed transmission of personal identifiers and automatic account creation **Risk Level**: Medium ### Vulnerable Code The identity sources are initialized in `skills/smyx_common/scripts/config.py:154-162`: ```python openclaw_sender_open_id = os.environ.get("OPENCLAW_SENDER_OPEN_ID") openclaw_sender_username = os.environ.get("OPENCLAW_SENDER_USERNAME") feishu_open_id = os.environ.get("FEISHU_OPEN_ID") if openclaw_sender_open_id: cls.CURRENT__OPEN_ID = openclaw_sender_open_id if openclaw_sender_username: cls.CURRENT__USER_NAME = openclaw_sender_username if feishu_open_id: cls.FEISHU_APP__RECEIVE_ID = feishu_open_id ``` The request helper then uses the selected value for automatic registration: ```python def _get_or_create_user(username): _url = ApiEnum.BASE_URL_HEALTH + "/sys/phoneLogin" open_id = username _data = { "silent": 1, "register": 1, "openId": open_id, "mobile": username, "source": ConstantEnum.DEFAULT__SKILL_HUB_NAME } try: _response = requests.post(_url, json=_data) if _response.status_code == 200: _response_json = _response.json() if _response_json and _response_json.get("success"): return _response_json and _response_json.get("result") except Exception as _e: CommonUtil.trace_exception_stack(_e) return {} # ... current__user_name = ( ApiEnum.API_SECRET_KEY or ConstantEnum.CURRENT__USER_NAME or ConstantEnum.CURRENT__OPEN_ID ) if (not ApiEnum.TOKEN or not ApiEnum.OPEN_TOKEN) and current__user_name: # ... if not ApiEnum.TOKEN or not ApiEnum.OPEN_TOKEN: new_current_user = _get_or_create_user(current__user_name) ``` ### Technical Analysis A sender identifier can be read from the host environment and used without an interactive consent step. If no l ...[truncated 1545 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require explicit, informed user consent before external account registration. 2. Separate account lookup from account creation; do not set `register: 1` during routine requests. 3. Never place an opaque open ID into a `mobile` field unless it has been validated as a phone number and the user has approved that use. 4. Transmit only the minimum identifier necessary for the requested operation. 5. Clearly disclose: - The destination service; - The identifier being transmitted; - Why an account is required; - How long account data and tokens are retained. 6. Provide a local-only or anonymous mode where account persistence is unnecessary. 7. Add account deletion, token revocation, and consent withdrawal mechanisms. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
skills/face_analysis/scripts/skill.py:102
Finding
Bundled Face-Analysis Component Can Upload Local Biometric Media Outside the Declared Device-Management Scope<![CDATA[ ## Vulnerability Details **File Location**: `skills/face_analysis/scripts/skill.py:102-129` **Vulnerability Type**: Undeclared sensitive local-file upload capability **Risk Level**: Medium ### Vulnerable Code ```python if not input_path: raise ValueError( "A local video path (--input) or network video URL (--url) is required" ) if input_path.startswith("http://") or input_path.startswith("https://"): params.update({ "videoUrl": input_path }) else: _validate_file(input_path) mime_type, _ = mimetypes.guess_type(input_path) if mime_type is None: mime_type = 'application/octet-stream' with open(input_path, 'rb') as f: file_content = f.read() files = { 'file': ( os.path.basename(input_path), file_content, mime_type ) } response = self.analysis( params=params, files=files ) ``` The upload endpoint is defined in `skills/face_analysis/scripts/config.py:13-20`: ```python class ApiEnum(ApiEnumBase): ANALYSIS_URL = "/web/health-analysis/v2/start-health-analysis" ANALYSIS_RESULT_URL = "/web/health-analysis/get-health-analysis-result" PAGE_URL = "/web/health-analysis/page-health-analysis-result" ``` ### Technical Analysis The top-level `SKILL.md` declares cloud device and camera management. The packaged project also includes a distinct face-analysis component that can read local video files and upload their complete contents to the configured external health-analysis service. Video showing a person's face is sensitive biometric and health-adjacent information. The implementation validates file existence, extension, readability, and size, but it does not implement an explicit consent prompt, destination confirmation, content warning, or local-path allowlist. The functionality is not automatically invoked by the reviewed device-management command path. Nevertheless, it is an executable component shipped in the ...[truncated 1043 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove the unrelated face-analysis component from the device-management package, or declare it as a separate Skill with its own permissions and documentation. 2. Require explicit confirmation immediately before each local media upload. 3. Display the exact destination hostname and categories of data being transmitted. 4. Restrict readable input paths to user-approved files or a dedicated import directory. 5. Avoid retaining complete media in memory where streaming upload is available. 6. Document retention, deletion, model-processing, and third-party sharing policies. 7. Provide remote-record deletion and consent withdrawal controls. 8. Ensure report links and biometric results require authenticated, user-scoped access. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/device_management.py:98
Finding
Device Login Credentials Can Be Persisted in Plaintext YAML<![CDATA[ ## Vulnerability Details **File Location**: `scripts/device_management.py:98-115` **Vulnerability Type**: Plaintext storage of device usernames and passwords **Risk Level**: Medium ### Vulnerable Code ```python def add_device(name: str, type: str, ip: str, username: Optional[str] = None, password: Optional[str] = None, **kwargs) -> Dict: config = load_config() if "devices" not in config: config["devices"] = [] device = { "id": generate_device_id(), "name": name, "type": type, "ip": ip, "username": username, "password": password, "status": "online", "created_at": datetime.now().isoformat(), "updated_at": datetime.now().isoformat(), **kwargs } config["devices"].append(device) save_config(config) return device ``` The save operation at `scripts/device_management.py:61-64` writes the structure directly to YAML: ```python def save_config(config: Dict) -> None: with open(CONFIG_PATH, "w", encoding="utf-8") as f: yaml.dump( config, f, default_flow_style=False, allow_unicode=True ) ``` ### Technical Analysis The local `add_device()` implementation includes the username and password directly in the device dictionary, then serializes the dictionary into a YAML file without encryption. This contradicts the top-level documentation, which claims device passwords are encrypted and not exposed in plaintext. YAML serialization provides no confidentiality. The active cloud registration branch in `main()` does not currently call this local helper, but the function remains callable by imports, tests, integrations, or future command-path changes. Its presence creates an unsafe credential-storage path. ### Attack Path 1. A caller invokes `add_device()` with a device username and password. 2. The credentials are inserted directly into ...[truncated 735 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove device passwords from YAML-backed data structures. 2. Store credentials in an operating-system credential manager or dedicated secret service. 3. Persist only a secret reference or credential identifier in device metadata. 4. If encrypted local storage is unavoidable, use authenticated encryption and keep the encryption key outside the YAML and project directory. 5. Apply restrictive owner-only permissions to configuration and secret files. 6. Remove credentials from logs, returned device dictionaries, and formatted output. 7. Correct the documentation so it accurately reflects implemented protections. 8. Search existing configuration files and backups for plaintext credentials, then rotate any discovered passwords. ]]>
Vulnerability Patterns
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
Findings (130)

Known Vulnerable Dependency: Authlib==1.6.6 — 14 advisory(ies): CVE-2026-28490 (Authlib Vulnerable to JWE RSA1_5 Bleichenbacher Padding Oracle); CVE-2026-28802 (Authlib: Setting `alg: none` and a blank signature appears to bypass signature v); CVE-2026-41425 (Authlib: Cross-site request forging when using cache) +11 more

Critical
Category
Supply Chain
Confidence
98% confidence
Finding
The requirements pin Authlib to 1.6.6, and the supplied advisories include critical issues affecting JWT/JWE/OAuth flows such as signature bypass and padding-oracle style attacks. In a device-management skill that may expose authenticated APIs, stream URLs, or camera controls, weaknesses in auth and token handling materially increase the risk of account takeover, token forgery, or unauthorized device access.

Known Vulnerable Dependency: GitPython==3.1.45 — 16 advisory(ies): CVE-2026-78676 (GitPython: Dormant multi-line git-config values are corrupted into live injected); CVE-2026-67325 (GitPython: Command Injection via git long-option prefix abbreviation bypass of C); CVE-2026-73620 (GitPython: Unguarded git option forwarding in IndexFile.checkout() and TagRefere) +13 more

Critical
Category
Supply Chain
Confidence
96% confidence
Finding
GitPython 3.1.45 is flagged with multiple critical advisories including command injection and unsafe option forwarding. If the skill or its supporting tooling interacts with repositories, branches, tags, or checkout paths derived from user or agent-controlled input, this can lead to arbitrary command execution or repository manipulation.

Known Vulnerable Dependency: langchain-core==1.0.2 — 12 advisory(ies): CVE-2026-26013 (LangChain affected by SSRF via image_url token counting in ChatOpenAI.get_num_to); CVE-2025-65106 (LangChain Vulnerable to Template Injection via Attribute Access in Prompt Templa); CVE-2026-40087 (LangChain has incomplete f-string validation in prompt templates) +9 more

Critical
Category
Supply Chain
Confidence
97% confidence
Finding
langchain-core 1.0.2 has multiple critical advisories including SSRF and template injection style issues. Because this skill appears to be an LLM-enabled device-management integration, SSRF could be especially dangerous by enabling access to internal device endpoints, metadata services, or private stream URLs, while template injection can subvert prompt or tool behavior.

Known Vulnerable Dependency: Authlib==1.6.6 — 14 advisory(ies): CVE-2026-28490 (Authlib Vulnerable to JWE RSA1_5 Bleichenbacher Padding Oracle); CVE-2026-28802 (Authlib: Setting `alg: none` and a blank signature appears to bypass signature v); CVE-2026-41425 (Authlib: Cross-site request forging when using cache) +11 more

Critical
Category
Supply Chain
Confidence
98% confidence
Finding
The requirements file pins Authlib to a version flagged by multiple advisories, including severe JWT/JWE validation and CSRF-related issues. In a device-management skill that may handle authentication, tokens, and live stream access, vulnerable auth libraries materially increase the risk of account compromise, token forgery, or unauthorized device access.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
89% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
This finding points to automatic login/token acquisition, token persistence, file writes, and generic HTTP wrappers beyond the user-facing description. In a device-control skill, silent authentication material handling and persistence are sensitive because they can expand access, enable cross-user confusion, and create durable secrets on disk.

Missing User Warnings

High
Confidence
98% confidence
Finding
The instruction to execute device-listing commands automatically when keywords appear removes a key human-approval checkpoint. Because device inventories and stream access are sensitive surveillance data, automatic execution materially increases the risk of data disclosure and unintended actions from ambiguous or injected prompts.

Known Vulnerable Dependency: click==8.3.1 — 1 advisory(ies): CVE-2026-7246 (Pallets Click, versions 8.3.2 and below, contain a command injection vulnerabili)

High
Category
Supply Chain
Confidence
80% confidence
Finding
If click 8.3.1 is affected by a command-injection vulnerability as indicated, any administrative tooling, deployment script, or maintenance command that passes untrusted input into Click-backed commands could become an execution vector. Even though this is a requirements file and exploitation depends on how the package is used, device-management environments often include operational scripts where command execution impact is significant.

Known Vulnerable Dependency: cryptography==3.4.8 — 16 advisory(ies): CVE-2023-50782 (Python Cryptography package vulnerable to Bleichenbacher timing oracle attack); GHSA-537c-gmf6-5ccf (Vulnerable OpenSSL included in cryptography wheels); GHSA-5cpq-8wj7-hf2v (Vulnerable OpenSSL included in cryptography wheels) +13 more

High
Category
Supply Chain
Confidence
97% confidence
Finding
cryptography 3.4.8 is an old security-sensitive package version with multiple advisories, including oracle and bundled OpenSSL issues. In a system handling HTTPS, tokens, certificates, or signed device-control traffic, weaknesses in cryptographic primitives or linked libraries can undermine confidentiality and authentication guarantees.

Known Vulnerable Dependency: httplib2==0.20.2 — 2 advisory(ies): CVE-2026-59939 (httplib2: Decompression Bomb Denial of Service via Unbounded gzip/deflate Respon); CVE-2026-59939 (httplib2 is a comprehensive HTTP client library for Python. Prior to 0.32.0, htt)

High
Category
Supply Chain
Confidence
93% confidence
Finding
httplib2 0.20.2 is reported vulnerable to decompression-bomb denial of service via unbounded compressed responses. In a service that may fetch remote resources such as stream metadata, auth endpoints, or third-party APIs, an attacker-controlled endpoint could trigger memory or CPU exhaustion.

Known Vulnerable Dependency: idna==3.11 — 2 advisory(ies): CVE-2026-45409 (Internationalized Domain Names in Applications (IDNA): Specially crafted inputs ); CVE-2026-45409 (Internationalized Domain Names in Applications (IDNA) for Python provides suppor)

High
Category
Supply Chain
Confidence
80% confidence
Finding
The dependency list includes idna 3.11 with reported security issues in handling crafted internationalized domain inputs. If this application accepts or constructs URLs for camera endpoints, callback hosts, or external integrations, IDNA parsing ambiguities could contribute to SSRF, validation bypass, or hostname confusion.

Known Vulnerable Dependency: langchain-openai==1.0.1 — 2 advisory(ies): GHSA-r7w7-9xr2-qq2r; PYSEC-2026-76

High
Category
Supply Chain
Confidence
90% confidence
Finding
langchain-openai 1.0.1 is reported with security advisories, and as a bridge between the application and model/tooling stack it can amplify prompt-injection, data-exfiltration, or unsafe request-processing issues. In this skill context, compromised model integration could expose camera metadata, device identifiers, or internal endpoints.

Known Vulnerable Dependency: langgraph==1.0.2 — 2 advisory(ies): GHSA-g48c-2wqr-h844; PYSEC-2026-83

High
Category
Supply Chain
Confidence
90% confidence
Finding
langgraph 1.0.2 is flagged by advisories affecting the agent workflow layer. Since agent graphs orchestrate tool calling and state transitions, vulnerabilities here can lead to unauthorized tool execution, state corruption, or leakage of device-management context in a system that may control or disclose surveillance resources.

Known Vulnerable Dependency: langgraph-checkpoint==3.0.0 — 4 advisory(ies): GHSA-fjqc-hq36-qh5p; GHSA-mhr3-j7m5-c7c9; PYSEC-2026-2573 +1 more

High
Category
Supply Chain
Confidence
89% confidence
Finding
langgraph-checkpoint 3.0.0 has multiple advisories, and checkpoint/state persistence vulnerabilities can expose or corrupt conversational and tool state. In a device-management skill, persisted state may include device identifiers, stream URLs, auth material, or prior tool outputs that should not be disclosed or tampered with.

Static analysis

Detected: suspicious.install_untrusted_source

Install source points to URL shortener or raw IP.

Warn
Code
suspicious.install_untrusted_source
Location
skills/smyx_common/scripts/config-dev.yaml:2