Back to skill

Security audit

ERP Claw

Security checks for vulnerabilities and agentic risk

Overview

ERPClaw is a coherent local ERP skill, but it gives broad business-data and host-admin authority and runs mutable remote code without strong integrity controls.

Install only if you are comfortable giving this skill control over a local ERP database with payroll/HR/accounting data and with module/dashboard setup that can run unpinned remote code. Avoid setup-web-dashboard and module updates on production systems unless you have reviewed and pinned the remote repositories, and require explicit backups and confirmations before restore, schema, cron, and deployment actions.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • 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
  • Embedded Malicious CodeShips malicious scripts inside the skill and executes them locally
Findings (5)

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/module_manager.py:486
Finding
Mutable Remote Module Code Is Downloaded and Executed Without Integrity Verification<![CDATA[ ## Vulnerability Details **File Location**: `scripts/module_manager.py:486-566` **Vulnerability Type**: Remote payload retrieval and supply-chain code execution **Risk Level**: High ### Vulnerable Code ```python clone_url = f"https://github.com/{github_repo}.git" result = subprocess.run( ["git", "clone", "--depth", "1", clone_url, install_path], capture_output=True, text=True, timeout=120 ) # Run init_db.py if it exists init_db_path = os.path.join(install_path, "init_db.py") tables_created = 0 if os.path.isfile(init_db_path): try: result = subprocess.run( [sys.executable, init_db_path], capture_output=True, text=True, timeout=60 ) if result.returncode != 0: _mark_failed(conn, module_name, f"init_db.py failed: {result.stderr.strip()}") err(f"init_db.py failed for {module_name}: {result.stderr.strip()}") ``` ### Technical Analysis The module installer clones the current head of a configured GitHub repository using a shallow clone and then executes a downloaded `init_db.py` file with the current Python interpreter. It does not pin the repository to an audited commit, verify a cryptographic digest, verify a signed tag, or inspect the downloaded code before execution. The module name must exist in the bundled registry, and the reviewed registry points to `avansaber/*` repositories. This reduces arbitrary-URL abuse but does not mitigate compromise of an allowed repository, maintainer account, GitHub organization, or upstream branch. The effective executable payload can change after this Skill package has been reviewed. The execution is necessary for the declared module-installation feature, but mutable branch-head execution grants more trust than the minimum privileges required. ### Attack Path 1. An attacker compromises an allowed repository or an authorized maintainer account. 2. The attacker modifies the repository's default branch and adds malicious behavior to ...[truncated 1057 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every module to an immutable reviewed commit hash rather than the default branch. 2. Store the expected commit and a SHA-256 manifest in `module_registry.json`. 3. Verify the resolved commit and all security-sensitive files before execution. 4. Prefer signed release tags and verify signatures against bundled trusted maintainer keys. 5. Present the exact repository, commit, signer, and changed-file summary to the user before execution. 6. Execute module initialization in a restricted subprocess with: - A minimal environment. - No unnecessary network access. - A dedicated temporary database or narrowly scoped database capability. - Filesystem access limited to the module directory and required ERP paths. 7. Do not automatically execute `init_db.py`; define a declarative migration format or require a separately confirmed initialization step. 8. Retain the verified commit hash in the installation audit record and refuse updates that fail signature or digest verification. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
scripts/erpclaw-meta/db_query.py:1808
Finding
Dashboard Setup Executes Unpinned Remote Build Dependencies and Deployment Scripts<![CDATA[ ## Vulnerability Details **File Location**: `scripts/erpclaw-meta/db_query.py:1808-1965` **Vulnerability Type**: Remote payload retrieval, dependency execution, and privileged deployment **Risk Level**: High ### Vulnerable Code ```python _WEB_REPO_URL = "https://github.com/avansaber/erpclaw-web.git" ok, stdout, stderr = _run_cmd( ["git", "clone", "--depth", "1", _WEB_REPO_URL, _WEB_DIR], timeout=120, ) ok, stdout, stderr = _run_cmd( ["npm", "install"], cwd=_WEB_DIR, timeout=300, ) pip_path = os.path.join(venv_dir, "bin", "pip") ok, stdout, stderr = _run_cmd( [pip_path, "install", "-r", requirements_file], cwd=api_dir, timeout=300, ) setup_script = os.path.join(_WEB_DIR, "deploy", "setup.sh") if os.path.isfile(setup_script): ok, stdout, stderr = _run_cmd( ["bash", setup_script], cwd=_WEB_DIR, timeout=120, ) ``` ### Technical Analysis The dashboard setup action clones the latest state of a remote repository, invokes `npm install`, installs Python dependencies from a downloaded requirements file, and executes a downloaded shell deployment script. These steps introduce several mutable execution layers: - The Git repository is not pinned to an audited commit. - npm packages may execute lifecycle scripts during installation. - Python dependencies are not shown to be hash-pinned. - The downloaded `deploy/setup.sh` is executed directly. - The deployment script is described as configuring nginx and systemd, potentially crossing into privileged system configuration. This behavior is related to the declared dashboard deployment feature, but it exceeds a least-privilege local ERP setup because unverified upstream code and dependency hooks can affect the host system. ### Attack Path 1. An attacker compromises the dashboard repository, an npm dependency, or a Python package referenced by the repository. 2. The user invokes `setup-web-dashboard`. 3. The Skill clones the current mutable repos ...[truncated 997 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the dashboard repository to a reviewed commit hash or cryptographically signed release. 2. Verify the commit signature and a bundled file manifest before running any build or deployment command. 3. Require and enforce npm lockfile integrity, preferably using `npm ci --ignore-scripts` unless lifecycle scripts have been individually reviewed. 4. Pin Python dependencies to exact versions and hashes, then install with `pip --require-hashes`. 5. Replace the remote shell deployment script with audited, locally bundled deployment logic. 6. Separate unprivileged build operations from privileged deployment operations. 7. Display every planned privileged change and require a dedicated confirmation immediately before applying it. 8. Run build steps in a sandbox without access to the ERP database, user home directory, SSH material, or unrelated environment variables. 9. Restrict outbound network access to explicitly required package registries during dependency resolution. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/erpclaw-os/generate_module.py:1325
Finding
User-Controlled Module Output Directory Allows Arbitrary File Overwrite<![CDATA[ ## Vulnerability Details **File Location**: `scripts/erpclaw-os/generate_module.py:1325-1425` **Vulnerability Type**: Unrestricted filesystem destination and overwrite **Risk Level**: High ### Vulnerable Code The user-invocable handler forwards `--output-dir` directly: ```python output_dir = getattr(args, "output_dir", None) src_root = getattr(args, "src_root", None) result = generate_module( module_name=module_name, prefix=prefix, business_description=business_description, entities=entities, output_dir=output_dir, src_root=src_root, ) ``` The generator then creates and overwrites files beneath that unrestricted destination: ```python if not output_dir: if src_root: output_dir = os.path.join(src_root, module_name) else: output_dir = module_name os.makedirs(output_dir, exist_ok=True) scripts_dir = os.path.join(output_dir, "scripts") os.makedirs(scripts_dir, exist_ok=True) tests_dir = os.path.join(scripts_dir, "tests") os.makedirs(tests_dir, exist_ok=True) init_db_path = os.path.join(output_dir, "init_db.py") with open(init_db_path, "w") as f: f.write(init_db_content) domain_path = os.path.join(scripts_dir, f"{module_short}.py") with open(domain_path, "w") as f: f.write(domain_content) db_query_path = os.path.join(scripts_dir, "db_query.py") with open(db_query_path, "w") as f: f.write(db_query_content) skill_md_path = os.path.join(output_dir, "SKILL.md") with open(skill_md_path, "w") as f: f.write(skill_md_content) ``` ### Technical Analysis `--output-dir` is accepted as a caller-controlled path without canonicalization, workspace containment, symlink rejection, or a check that the destination is empty. Absolute paths and traversal paths can therefore select any directory writable by the ERPClaw process. The use of write mode (`"w"`) silently truncates existing files. The generated filenames include executable Python entry points and `SKILL.md`, which may influence later Agent ...[truncated 1409 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Define a dedicated generation root, such as `~/.openclaw/erpclaw/generated-modules`. 2. Canonicalize the root and destination with `os.path.realpath`. 3. Verify with `os.path.commonpath` that the final destination remains inside the generation root. 4. Reject absolute paths, `..` components, control characters, and invalid module-name characters. 5. Use `os.open` with exclusive creation semantics or otherwise refuse to overwrite existing files by default. 6. Reject non-empty destination directories unless a separate overwrite flag is supplied and explicitly confirmed. 7. Check every destination component with `lstat` and reject symlinks. 8. Generate into a fresh temporary directory, validate all output, and atomically rename it into place. 9. Apply restrictive permissions to generated files and directories. 10. Do not permit direct generation into installed Skill directories through the normal user-invocable action. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/erpclaw-meta/db_query.py:1967
Finding
Unsanitized Domain Is Embedded in a Privileged sed Program<![CDATA[ ## Vulnerability Details **File Location**: `scripts/erpclaw-meta/db_query.py:1967-1978` **Vulnerability Type**: Command-language injection into privileged configuration modification **Risk Level**: High ### Vulnerable Code ```python if domain: # Update nginx server_name in the installed config nginx_conf = "/etc/nginx/sites-available/erpclaw-web" if os.path.isfile(nginx_conf): ok, stdout, stderr = _run_cmd( ["sudo", "sed", "-i", f"s/server_name .*/server_name {domain};/", nginx_conf], timeout=10, ) if ok: # Reload nginx to pick up the domain change _run_cmd(["sudo", "nginx", "-t"], timeout=10) _run_cmd(["sudo", "systemctl", "reload", "nginx"], timeout=10) ``` ### Technical Analysis The code avoids a shell and supplies subprocess arguments as a list, which prevents ordinary shell metacharacter injection. However, the untrusted `domain` value is embedded directly into a `sed` program. A subprocess argument can still be vulnerable when it is interpreted by another command language. Sed delimiters, backslashes, newlines, replacement operators, and additional sed commands are not escaped. A crafted domain can therefore terminate or modify the intended substitution and cause unauthorized transformations of the root-owned nginx configuration. The command is invoked through `sudo`. Exploitability depends on the local sudo policy and the sed implementation. Where the invocation is authorized, the injected sed program operates with elevated privileges. Implementation-specific sed features may further increase impact. ### Attack Path 1. An attacker supplies a crafted `--domain` containing sed syntax, delimiters, or embedded commands. 2. The value is interpolated into `s/server_name .*/server_name {domain};/`. 3. `sudo sed -i` interprets the entire argument as a sed program rather than as inert domain data. 4. The injected sed behavior ...[truncated 865 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Strictly validate `domain` before use: - Accept only valid DNS labels and optional validated IP literals. - Reject whitespace, newlines, slashes, backslashes, semicolons, and control characters. - Enforce a conservative maximum length. 2. Do not construct a sed program from user input. 3. Parse and update an nginx template using application code, then validate the complete generated configuration. 4. Write the proposed configuration to an unprivileged temporary file. 5. Run `nginx -t -c <temporary-file>` before replacing the live configuration. 6. Use a narrowly scoped privileged helper that only installs a validated configuration file at the expected path. 7. Require explicit confirmation immediately before any `sudo` operation. 8. Configure sudoers to allow only the minimal deployment helper, not general `sed`, shell, or unrestricted configuration commands. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/erpclaw-setup/lib/erpclaw_lib/crypto.py:214
Finding
Field-Level Encryption Does Not Authenticate Ciphertext<![CDATA[ ## Vulnerability Details **File Location**: `scripts/erpclaw-setup/lib/erpclaw_lib/crypto.py:214-244` **Vulnerability Type**: Malleable unauthenticated encryption **Risk Level**: Medium ### Vulnerable Code ```python def encrypt_field(value: str, key: bytes) -> str: if not value or value.startswith(FIELD_PREFIX): return value iv = os.urandom(16) plaintext = value.encode("utf-8") # Encrypt using CTR mode ciphertext = _aes_encrypt_block(key, iv, plaintext) # Encode: iv + ciphertext encoded = base64.b64encode(iv + ciphertext).decode("ascii") return FIELD_PREFIX + encoded def decrypt_field(value: str, key: bytes) -> str: if not value or not value.startswith(FIELD_PREFIX): return value encoded = value[len(FIELD_PREFIX):] raw = base64.b64decode(encoded) iv = raw[:16] ciphertext = raw[16:] plaintext = _aes_decrypt_block(key, iv, ciphertext) return plaintext.decode("utf-8") ``` ### Technical Analysis Field encryption stores only the IV and stream-cipher ciphertext. It does not generate or verify an authentication tag. CTR-style encryption is malleable: changing a ciphertext bit causes a corresponding predictable change in the decrypted plaintext bit. An attacker who can modify encrypted database fields may therefore alter plaintext without knowing the key. Whether a meaningful targeted change is possible depends on knowledge or predictability of the original value. Random corruption may also go undetected until decoding or business validation occurs. The Base64 operation is only a local representation format and is not evidence of data exfiltration. No network sink was found in this encryption utility. ### Attack Path 1. An attacker obtains write access to the SQLite database, a backup, or another storage location containing an `enc:` field. 2. The attacker modifies selected bytes in the Base64-decoded ciphertext. 3. The application decodes and decrypts the modified value ...[truncated 820 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace the custom stream-cipher construction with a standard authenticated-encryption algorithm such as AES-GCM or ChaCha20-Poly1305 from a maintained cryptographic library. 2. Generate a unique nonce according to the selected algorithm's requirements. 3. Authenticate field identity, company ID, table name, and record ID as associated data to prevent ciphertext relocation between records. 4. Version the encrypted field format so legacy values can be migrated safely. 5. Reject truncated, malformed, or unauthenticated ciphertext before attempting plaintext decoding. 6. Develop a migration process that decrypts existing values and re-encrypts them with authenticated encryption. 7. Keep encryption keys outside the database and apply explicit key rotation and access-control procedures. 8. Do not describe the existing custom HMAC-based stream construction as AES, because it is not an AES implementation. ]]>
Vulnerability Patterns
  • 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
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (227)

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
Database initialization/re-initialization, backup/restore, encrypted backup verification, external API access, RBAC administration, Telegram linking, local onboarding state, and subprocess orchestration are powerful administrative capabilities not sufficiently emphasized by the business-oriented description. In a local ERP containing PII, payroll, and accounting records, hidden admin and integration features substantially increase confidentiality, integrity, and availability risk if invoked unexpectedly.

Static analysis

No suspicious patterns detected.