Back to skill

Security audit

Driver Blink-Rate & Eye-Closure Fatigue Detection | 驾驶员眨眼频率与闭眼时长检测

Security checks across malware telemetry and agentic risk

Overview

The skill is broadly aligned with driver video fatigue analysis, but it silently creates and persists identity/token state while uploading sensitive video and report data to APIs.

Review this skill before installing in any real driver-monitoring environment. Confirm the API endpoints, disable unintended dev/private endpoints, obtain explicit driver or employee consent, and require clear retention/deletion rules for uploaded videos, reports, local SQLite data, and stored tokens.

SkillSpector

By NVIDIA
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • Behavioral ASTexec() Call, eval() Call, Dynamic Import
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (22)

Dynamic attribute access via getattr()

Low
Category
Dangerous Code Execution
Content
if filters:
                for key, value in filters.items():
                    query = query.filter(getattr(self.__model__, key) == value)

            if offset:
                query = query.offset(offset)
Confidence
76% confidence
Finding
This code applies user-supplied filter keys directly via getattr(self.__model__, key) with no allowlist or existence check. While SQLAlchemy prevents classic SQL injection here, an attacker controlling filter names can trigger exceptions, enumerate model structure, or query unintended sensitive columns such as token fields, which is more concerning given this skill stores identity and token data unrelated to fatigue detection.

Dynamic attribute access via getattr()

Low
Category
Dangerous Code Execution
Content
if filters:
                for key, value in filters.items():
                    query = query.filter(getattr(self.__model__, key) == value)

            return query.scalar()
        finally:
Confidence
75% confidence
Finding
The count() method repeats the same dynamic filter-key pattern, allowing unvalidated attribute access on the model. Even without raw SQL injection, this can expose schema details, enable unauthorized querying over sensitive fields, and cause denial-of-service via repeated invalid requests if externally reachable.

Lp3

Medium
Category
MCP Least Privilege
Confidence
92% confidence
Finding
The skill documents capabilities that imply shell, filesystem, environment, and network access without any declared permission boundary or user-visible scoping. In a skill that handles sensitive driver video and identity-linked history, this creates a transparency and governance gap that can enable over-privileged execution, data exfiltration, or unintended local system access.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The documented purpose is local blink/fatigue analysis, but the behavior apparently sends driver video and metadata to remote endpoints, performs unrelated account/token operations, and manages persistent identities. This mismatch is dangerous because users and integrators may expose biometric video and identity data under false assumptions about local-only processing and limited functionality.

Description-Behavior Mismatch

Medium
Confidence
87% confidence
Finding
Claiming real-time fatigue analysis while also performing cloud report retrieval and remote report linking expands the data lifecycle beyond what the top-level description suggests. For a driver-monitoring skill processing biometric-like video, this increases privacy and data-sharing risk because historical records may be queried or surfaced unexpectedly.

Description-Behavior Mismatch

Medium
Confidence
84% confidence
Finding
The documentation introduces automatic local file saving and cloud history-query behavior that is not reflected in the manifest description. Hidden persistence and remote querying are risky because uploaded driver videos and associated results may be stored or retrieved in ways users and operators did not anticipate.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
Automatic creation or reuse of internal user identities is not necessary for basic blink-fatigue analysis and introduces silent identity binding for sensitive driver-monitoring data. This can enable persistent tracking, cross-session correlation, and unexpected access to historical reports without clear user awareness or consent.

Description-Behavior Mismatch

Medium
Confidence
89% confidence
Finding
The skill is described as performing real-time driver blink/fatigue analysis on a provided video, but it also exposes a function to list prior analysis results by user identity. That introduces a data-access capability unrelated to the stated purpose and could expose historical biometric or behavioral monitoring results if access control is weak or identity resolution is confused.

Context-Inappropriate Capability

Medium
Confidence
92% confidence
Finding
The script initializes and uses an internal open_id even though the visible function of the tool is video fatigue analysis. Hidden identity handling expands the trust boundary and can enable unauthorized access to another user's analysis history or silent collection/linkage of sensitive driver-monitoring data, especially because the open_id parameter is suppressed from help output.

Description-Behavior Mismatch

Medium
Confidence
90% confidence
Finding
The skill accepts arbitrary HTTP/HTTPS video URLs and forwards them to the backend analysis service, even though the declared purpose is analysis of in-cabin DMS camera input. This expands the data ingress surface beyond the documented scope and can enable misuse such as analyzing untrusted external content, privacy-invasive uploads, or backend access to attacker-controlled URLs.

Context-Inappropriate Capability

Medium
Confidence
72% confidence
Finding
The file exposes a history-list retrieval path via `--list` and `show_analyze_list(open_id)` that is not necessary for the stated blink-fatigue detection function. In a driver-monitoring context, analysis history can contain sensitive biometric/behavioral data or metadata, so unnecessary listing functionality increases privacy and unauthorized-access risk if access control is weak elsewhere in the stack.

Context-Inappropriate Capability

Medium
Confidence
89% confidence
Finding
The file exposes broad generic CRUD and arbitrary HTTP wrapper methods (http_get/http_post/http_put/http_delete, add/edit/delete/page/list) that are not constrained to the stated fatigue-detection use case. In a skill intended for blink/fatigue analysis, these capabilities can be repurposed to interact with unrelated internal or external services, increasing the attack surface and enabling unauthorized data access or unintended side effects if other components can influence the URLs or parameters.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
This file defines generic persistent storage for user records, names, email, birthdays, and tokens, which does not align with the stated blink/fatigue-analysis purpose. Unnecessary identity and credential-like data handling expands attack surface and privacy risk, especially in a driver-monitoring context where users would not expect account persistence to be bundled into camera-based fatigue detection.

Context-Inappropriate Capability

High
Confidence
98% confidence
Finding
The User model stores token and open_token fields alongside identity attributes without any justification from the skill description. Collecting authentication-like secrets in a fatigue-detection skill is dangerous because compromise of the local SQLite database could expose credentials or session material unrelated to the declared function.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
This shared utility performs remote account provisioning, token acquisition, token persistence, and authenticated HTTP API access, which is materially unrelated to the stated blink/fatigue video-analysis purpose. In the context of a narrowly scoped driver-monitoring skill, hidden networked identity and account behaviors expand the trust boundary and can exfiltrate identifiers or create remote side effects without clear user awareness.

Context-Inappropriate Capability

Medium
Confidence
96% confidence
Finding
The code reads local identity material and creates or persists default user identities when none are supplied, even though the declared skill purpose is fatigue detection from in-cabin video. That mismatch makes the behavior suspicious because it silently establishes identity state and durable user records outside the expected function of the skill.

Context-Inappropriate Capability

Medium
Confidence
84% confidence
Finding
The utility enumerates environment variables and filesystem layout to discover agent/workspace context far beyond what is needed for blink-rate or eye-closure analysis. While this may be framework plumbing rather than overtly malicious logic, it broadens local reconnaissance capability and helps other code locate sensitive directories such as skills/ and data/.

Vague Triggers

Medium
Confidence
81% confidence
Finding
A default trigger that fires on essentially any uploaded driver-face video is overly broad and can cause unintended processing of sensitive in-cabin footage. In this context, accidental invocation could send private biometric and behavioral data into analysis and storage pipelines without sufficiently explicit user intent.

Missing User Warnings

Medium
Confidence
85% confidence
Finding
The code reads arbitrary local file contents into memory and transmits them to the analysis API without any visible user-facing disclosure, consent prompt, or minimization step in this code path. Because the skill processes video that may contain biometric and highly sensitive personal data, silent transmission increases privacy and data-handling risk.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The function reads a sensitive identity value from data/smyx-api-key.txt and uses it as an internal identity source without any user-facing disclosure or consent flow. In a driver-fatigue analysis skill, this is especially concerning because users would reasonably expect local vision processing, not silent harvesting of workspace identity material.

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The request wrapper automatically attaches user identity and authentication tokens to outbound HTTP requests and may include pnaUserName and other metadata in request bodies. Without a clear consent or disclosure boundary, this can silently transmit sensitive identity and session material to external services, which is not justified by the stated blink/fatigue detection use case.

External Transmission

Medium
Category
Data Exfiltration
Content
"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"):
Confidence
95% confidence
Finding
This code sends openId/mobile/source data to a remote /sys/phoneLogin endpoint to create or retrieve a user account. That is an external transmission of identity-related data unrelated to core fatigue detection, creating privacy and account-lifecycle side effects that a user would not expect from an in-cabin blink-analysis skill.

VirusTotal

VirusTotal findings are pending for this skill version.

View on VirusTotal

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