Back to skill

Security audit

FlowBridge

Security checks for vulnerabilities and agentic risk

Overview

FlowBridge is a coherent automation skill, but its advertised permission, approval, audit, and compliance controls are not strong enough for the sensitive cross-platform workflows it encourages.

Review this skill before installing in any real workspace. Treat it as a prototype unless you add explicit admin approval, workflow execution authorization, audit-export permissions, safe export paths, privacy warnings for chat/file/approval templates, and pinned dependencies. Do not connect real WeChat, DingTalk, Feishu, WPS, Tencent Docs, or Aliyun Drive credentials until those controls are in place.

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

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/permission_manager.py:108
Finding
Authorization Controls Can Be Bypassed for Role Assignment and Workflow Operations<![CDATA[ ## Vulnerability Details **File Location**: `scripts/permission_manager.py:108-198`; related unenforced workflow operations in `scripts/workflow_engine.py:139-355` **Vulnerability Type**: Missing authorization checks and privilege escalation **Risk Level**: High ### Vulnerable Code `scripts/permission_manager.py:108-154` ```python def create_user( self, user_id: str, name: str, role: UserRole = UserRole.MEMBER, team_id: str = "" ) -> User: """ 创建用户 Args: user_id: 用户ID name: 用户名称 role: 角色 team_id: 团队ID Returns: User: 用户对象 """ permissions = self.role_permissions.get(role, []) user = User( id=user_id, name=name, role=role, team_id=team_id, permissions=permissions ) self.users[user_id] = user # 记录审计日志 self._log_audit( user_id=user_id, action='user:create', resource_type='user', resource_id=user_id, details={'name': name, 'role': role.value} ) return user ``` `scripts/permission_manager.py:175-198` ```python def assign_role(self, user_id: str, role: UserRole) -> bool: """ 分配角色 Args: user_id: 用户ID role: 新角色 Returns: bool: 是否成功 """ user = self.get_user(user_id) if not user: return False old_role = user.role user.role = role user.permissions = self.role_permissions.get(role, []) # 记录审计日志 self._log_audit( user_id=user_id, action='user:assign_role', resource_type='user', resource_id=user_id, details={'old_role': old_role.value, 'new_role': role.value} ) return True ``` Relevant workflow entry points accept no authenticated actor or authorization context: `scripts/workflow_engine.py:139-156` ```python def create_workflow(self, name: str, description: str = "") -> Workflow: workflow_id = str(uuid.uuid4())[:8] workflow = Wor ...[truncated 2996 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require an authenticated actor identity for every privileged operation: ```python def assign_role(self, actor_id: str, target_user_id: str, role: UserRole) -> bool: if not self.check_permission(actor_id, "team:manage"): raise PermissionError("Insufficient permission") ``` 2. Restrict administrator account creation to a controlled bootstrap process. Normal account-creation APIs must not accept an arbitrary administrator role. 3. Prohibit self-promotion and require stronger authorization or multi-party approval for granting administrator access. 4. Pass an authenticated principal into all workflow mutation and execution methods. 5. Enforce permissions inside `WorkflowEngine`, rather than relying on callers to perform optional checks: - `workflow:create` for creation - `workflow:edit` for node and connection changes - `workflow:delete` for deletion - `workflow:execute` for execution 6. Associate workflows with owners and teams, then enforce resource-level authorization in addition to role-level permission checks. 7. Before execution, require an approved workflow record where approval is mandated. Bind approval to an immutable workflow version or content hash so a workflow cannot be changed after approval. 8. Record both the actor and target account in audit events. Do not attribute administrative role changes to the target user. 9. Add negative security tests proving that guests and members cannot promote users, approve workflows, execute unauthorized workflows, or bypass pending/rejected approvals. ]]>

T08 · Insecure Dependencies

Warning
Location
requirements.txt:1
Finding
Mutable Dependency Constraints Prevent Reproducible and Integrity-Verified Installation<![CDATA[ ## Vulnerability Details **File Location**: `requirements.txt:1-4`; installation instructions in `README.md:49` and `SKILL.md:38` **Vulnerability Type**: Unpinned third-party dependencies without package hashes **Risk Level**: Medium ### Vulnerable Code `requirements.txt:1-4` ```text requests>=2.31.0 pyyaml>=6.0 python-dateutil>=2.8.0 schedule>=1.2.0 ``` `README.md:49` and `SKILL.md:38` ```bash pip install -r requirements.txt ``` ### Technical Analysis Every dependency uses a lower-bound constraint. A fresh installation can therefore resolve to any later version accepted by the package index at installation time. The project does not provide a lock file, exact versions, package hashes, or an instruction to use pip's `--require-hashes` integrity mode. This does not establish that any currently listed package is malicious. The weakness is that reviewed source code does not determine the actual dependency artifacts that users will install. Future releases, compromised releases, or unexpected compatibility changes can silently alter the installation's effective code. Python package installation may execute package build logic, and imported dependencies execute within the application's security context. Consequently, dependency resolution is part of the project's executable supply chain and should be reproducible and integrity-verified. ### Attack Path 1. A user follows the documented installation command: ```bash pip install -r requirements.txt ``` 2. The package resolver queries the configured Python package index. 3. Because only minimum versions are specified, the resolver selects newer versions available at that time. 4. If a selected release is compromised, unexpectedly replaced, or otherwise unsafe, its installation or imported runtime code executes with the user's privileges. 5. The resulting environment differs from the dependency set originally reviewed and tested. ### Impact Assessment A compromised dependency could execute arbitra ...[truncated 430 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every direct and transitive dependency to an exact, reviewed version. 2. Generate a deterministic lock file using a dependency-management tool such as `pip-tools`, Poetry, or an equivalent controlled process. 3. Include cryptographic hashes for all resolved artifacts and install with: ```bash pip install --require-hashes -r requirements.txt ``` 4. Use a trusted package index or an internally controlled package mirror. 5. Add automated dependency vulnerability and provenance scanning to continuous integration. 6. Review dependency updates through pull requests rather than accepting future releases automatically. 7. Separate development and runtime dependencies, and remove packages not actually used by the implementation to reduce supply-chain exposure. 8. Document the supported Python version and platform so generated locks remain deterministic across deployment environments. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (35)

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding
The second mismatch is more severe because the described purpose emphasizes ecosystem integration, but the detected behavior includes user/role/permission management, approval processing, audit log export, and sensitive-action checks, while showing no evidence of the claimed platform integrations. That gap can conceal a materially different security posture, including collection of access-control and audit data that users did not reasonably expect.

Tp4

High
Category
MCP Tool Poisoning
Confidence
93% confidence
Finding
The second mismatch is more severe because the described purpose emphasizes ecosystem integration, but the detected behavior includes user/role/permission management, approval processing, audit log export, and sensitive-action checks, while showing no evidence of the claimed platform integrations. That gap can conceal a materially different security posture, including collection of access-control and audit data that users did not reasonably expect.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The README promotes workflows that automatically sync files, back up chat records, and send messages across platforms, but it does not prominently warn about privacy, consent, retention, or authorization risks. In a no-code automation tool handling personal and enterprise data, this omission can lead users to deploy flows that exfiltrate sensitive content or process personal data without adequate review.

Lp3

Medium
Category
MCP Least Privilege
Confidence
84% confidence
Finding
The skill advertises and demonstrates executable automation behavior that can write or sync files, but it does not declare any explicit tool scope or permissions. Missing scope declarations reduce transparency and allow users or downstream systems to underestimate the skill's ability to modify local data or move files across systems.

Missing User Warnings

Medium
Confidence
87% confidence
Finding
The skill promotes automated cross-platform syncing, including moving files between messaging and cloud-storage ecosystems, but does not warn users about data transfer, duplication, destination trust boundaries, or accidental propagation of sensitive files. In this context, omission of transfer warnings increases the likelihood of privacy leaks and policy violations during routine automation use.

Natural-Language Policy Violations

Medium
Confidence
91% confidence
Finding
This manifest is entirely oriented around Chinese-language services and labels (e.g. 微信, 钉钉, 飞书, 腾讯文档, 阿里云盘) with no indication that the locale restriction is optional or region-specific. Under the policy, a skill that implicitly forces a specific language/locale without user opt-in or documented justification should be flagged.

Description-Behavior Mismatch

Medium
Confidence
96% confidence
Finding
The manifest describes the skill as a no-code automation tool with WeChat, DingTalk, Feishu, and WPS integration. This configuration also enables Tencent Docs and Aliyun Drive connectors, which materially expand the skill's operational scope beyond the integrations named in the description.

Missing User Warnings

Medium
Confidence
83% confidence
Finding
This Python example obtains an auth URL, simulates authorization, and executes a WeChat send_message action, which implies network interaction and transmission of user/system data to an external platform. While the code prints results, it does not warn the user that the example contacts or authorizes against external services or may transmit message content and tokens.

Natural-Language Policy Violations

Medium
Confidence
93% confidence
Finding
The natural-language description explicitly states "中文语义理解" as a feature, which indicates a language-specific constraint. Because the file does not offer user opt-in or explain that the skill is intentionally limited to a Chinese-only context, this is a natural-language policy issue.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The generator automatically converts natural-language input into operational workflow actions such as file synchronization, notification sending, and document creation, including critical cross-platform file movement, without any approval gate, allowlist, or risk acknowledgment. In a no-code automation product that connects external platforms, this can cause unintended data exfiltration, propagation of sensitive files, or destructive/incorrect automation from ambiguous user instructions.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
The module name, docstrings, comments, and user-visible notification strings are written in Chinese throughout the file, with no indication that language selection is configurable or intentionally limited to a region-specific use case. This creates a natural-language locale policy concern because the skill appears to impose a specific language without user opt-in.

Description-Behavior Mismatch

Medium
Confidence
91% confidence
Finding
The manifest describes a no-code cross-platform automation tool with integrations, and this module presents itself as an execution monitor for real-time status, logging, alerts, and reporting. However, export_logs performs filesystem writes to arbitrary paths, which is a materially broader behavior than in-memory monitoring/reporting and is not implied by the module or manifest description.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The export_logs method writes collected execution logs, including execution IDs, workflow names, node names, actions, status, and error fields, to a filesystem path. Although this file documents the method technically, it does not provide any user-facing warning, confirmation, or disclosure that monitored execution data will be persisted to disk.

Natural-Language Policy Violations

Medium
Confidence
78% confidence
Finding
The file-level description and inline documentation are written in Chinese and present the skill as a Chinese-language permission manager, with no indication that users may choose another language or that the locale restriction is required for a region-specific purpose. This can violate language/locale policy when a skill effectively forces one language without opt-in.

Context-Inappropriate Capability

Medium
Confidence
94% confidence
Finding
The export_audit_logs function accepts an arbitrary filepath and writes audit data directly to that location without any authorization check, path restriction, or safety controls. In a larger system, this can enable unauthorized creation or overwrite of local files and turns sensitive audit data into a filesystem write primitive, which is more dangerous than the stated permission-management purpose requires.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The audit export writes potentially sensitive user activity records to disk with no permission check, confirmation, redaction, or encryption. Audit logs commonly contain identifiers, workflow names, reasons, and operational history, so exporting them freely increases the risk of privacy leakage and secondary disclosure from insecure storage.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The chat-backup template automates collection, organization, and storage of potentially sensitive chat records into documents without any built-in consent prompt, sensitivity warning, or data-minimization control. In an automation tool that bridges messaging and document platforms, this increases the risk of over-collection, unintended retention, and disclosure of personal or business communications.

Missing User Warnings

Medium
Confidence
90% confidence
Finding
This template exports approval records from DingTalk and archives them to external cloud storage, but the template metadata and creation flow do not disclose that potentially sensitive approval data will be transmitted and retained in another system. Because approvals may contain HR, finance, or internal operational data, silent cross-system archival can create confidentiality, compliance, and access-control risks.

Missing User Warnings

Medium
Confidence
93% confidence
Finding
The enterprise summary template aggregates exported data from multiple office platforms into a consolidated report without surfacing the privacy and governance implications of cross-platform aggregation. Aggregation can increase sensitivity by combining datasets that were previously separated, potentially exposing broader business intelligence or regulated information to users or systems that should not receive it.

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
This Python file contains user-facing natural-language descriptions entirely in Chinese, including the module header and class/method docstrings, with no indication that another language is supported. Under the policy rule, forcing a specific language without user opt-in is a natural-language policy violation.

Natural-Language Policy Violations

Low
Confidence
83% confidence
Finding
The feature list explicitly states '中文语义理解' as part of AI workflow generation, and the overall documentation is presented as Chinese-first without indicating whether other languages are supported or whether Chinese-only behavior is an intentional regional constraint. Under the policy, forcing a specific language without user opt-in can be a natural-language policy issue unless the locale limitation is clearly documented and justified.

Natural-Language Policy Violations

Low
Confidence
75% confidence
Finding
Most of the instructional content is presented only in Chinese, despite the brief bilingual description line. This can amount to a language/locale policy issue because the skill does not state that Chinese is optional, user-selected, or required for a documented region-specific reason.

Natural-Language Policy Violations

Low
Confidence
93% confidence
Finding
The natural-language strings, comments, and user-facing output in this skill file are exclusively in Chinese, which effectively forces a specific language for users. The file does not indicate that Chinese is optional, configurable, or required for a region-specific use case.

Intent-Code Divergence

Low
Confidence
87% confidence
Finding
The docstring and printed output present this function as a runnable '执行监控' example, but the code calls ExecutionStatus.SUCCESS at L203 and L207 without importing ExecutionStatus anywhere in the file. This means the example will raise a NameError instead of demonstrating successful execution monitoring, so the documented intent of the example diverges from what the code actually does.

Unpinned Dependencies

Low
Category
Supply Chain
Content
requests>=2.31.0
pyyaml>=6.0
python-dateutil>=2.8.0
schedule>=1.2.0
Confidence
96% confidence
Finding
The dependency is specified with a lower bound only, which allows different builds to resolve to different versions over time. This weakens reproducibility and can permit installation of vulnerable or incompatible releases if the package index or environment changes.

Static analysis

No suspicious patterns detected.