Back to skill

Security audit

CAD Viewer

Security checks for vulnerabilities and agentic risk

Overview

This CAD analysis skill appears legitimate in purpose, but it needs review because setup can make privileged system changes from unverified downloads and the skill tells agents to trust persistent project learning files.

Install only if you are comfortable with an agent skill that can run a setup script using sudo and network downloads. Prefer manual, verified installation of ODA/QCAD and Python dependencies, avoid running setup as root unless necessary, and disable or ignore the .learning mechanism unless you intentionally want project-local memory that future agent sessions will read.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • 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
Findings (5)

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:372
Finding
Persistent Project-Controlled Agent Memory Is Automatically Trusted<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:372-376`, `SKILL.md:409-424`, and `SKILL.md:435-440` **Vulnerability Type**: Persistent agent memory poisoning **Risk Level**: High ### Vulnerable Code ```markdown ## Self-Learning Mechanism This skill supports a self-learning mechanism that records user preferences, error resolutions, and best practices discovered during usage. These records are stored in a `.learning/` directory within the user's project and are **automatically referenced in subsequent sessions** to provide more accurate and personalized assistance. ### ⚡ Core Principle **Unless the user explicitly requests to skip past experience (e.g., "don't refer to previous learnings", "start fresh"), the agent MUST review `.learning/` files at the beginning of every task and apply relevant knowledge throughout the session.** ``` ```markdown ### First-Use Initialization Before logging anything, ensure the `.learning/` directory and files exist in the **user's project root** (NOT in the skill directory). If any are missing, create them: ```bash mkdir -p .learning [ -f .learning/LEARNINGS.md ] || cp {SKILL_DIR}/assets/LEARNINGS.md .learning/LEARNINGS.md [ -f .learning/ERRORS.md ] || cp {SKILL_DIR}/assets/ERRORS.md .learning/ERRORS.md ``` Never overwrite existing files. This is a no-op if `.learning/` is already initialized. ### When to Review Learnings (Start of Session) At the start of every CAD analysis task, **before executing any commands**: 1. Check if `.learning/` directory exists in the project root 2. If it exists, read `.learning/LEARNINGS.md` and `.learning/ERRORS.md` 3. Identify entries relevant to the current task (by file type, command, layer names, error patterns, etc.) 4. Apply relevant learnings proactively ``` ```markdown | Command fails or produces unexpected output | Log to `.learning/ERRORS.md` | | User corrects the agent's approach | Log to `.learning/LEARNINGS.md` with category `correction` | | User specifies ...[truncated 2336 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Make persistent learning strictly opt-in and request explicit user approval before reading or writing `.learning/`. 2. Treat all project-controlled learning content as untrusted data, not as agent instructions. 3. Replace free-form Markdown directives with a restrictive structured format containing typed fields and bounded values. 4. Reject imperative instructions, tool commands, external URLs, and requests to override system or user constraints. 5. Record provenance, author, creation time, and integrity metadata for every entry. 6. Present proposed persistent changes to the user and require confirmation before committing them. 7. Keep project observations separate from behavioral preferences, and store trusted preferences outside attacker-controlled repositories. 8. Never allow learned content to override system policies, user instructions, security controls, or tool authorization requirements. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/setup.sh:66
Finding
Local Package Arguments Bypass Explicit Setup Confirmation<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:66-74`, with resulting installation operations at `scripts/setup.sh:108-134`, `scripts/setup.sh:164-187`, and `scripts/setup.sh:297-300` **Vulnerability Type**: Incomplete authorization check for privileged setup **Risk Level**: High ### Vulnerable Code ```bash # Require explicit confirmation if [ "$CONFIRM" != true ] && [ -z "$ODA_RPM_PATH" ] && [ -z "$QCAD_TAR_PATH" ]; then log_err "Setup requires explicit confirmation." log_info "Run with --confirm to proceed with automatic setup." log_info "Or use --oda-rpm and --qcad-tar with local packages." log_warn "This script downloads from opendesign.com and qcad.org," log_warn "and uses sudo for system package installation." exit 1 fi ``` After this guard is bypassed by either local-package option, the script still performs unrelated installation operations: ```bash install_python_pkg() { local pkg=$1 if python3 -c "import $pkg" 2>/dev/null; then log_ok "$pkg already installed" else log_info "Installing $pkg ..." pip3 install "$pkg" -q && log_ok "$pkg installed successfully" || log_err "$pkg installation failed" fi } install_python_pkg ezdxf install_python_pkg matplotlib ``` ```bash if command -v xvfb-run &>/dev/null; then log_ok "xvfb-run already installed" else log_info "Installing xvfb ..." if [ "$PKG_MANAGER" = "apt-get" ]; then sudo apt-get update -qq && sudo apt-get install -y -qq xvfb else sudo $PKG_MANAGER install -y xorg-x11-server-Xvfb 2>/dev/null || \ sudo $PKG_MANAGER install -y Xvfb 2>/dev/null || \ sudo $PKG_MANAGER install -y xvfb 2>/dev/null || \ log_warn "xvfb installation failed, ODA and QCAD graphics rendering may be unavailable" fi fi ``` ```bash if [ "$QCAD_INSTALLED" = true ]; then log_info "Checking QCAD system dependencies..." if [ "$PKG_MANAGER" = "apt-get" ]; then sudo apt-get ...[truncated 1827 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Require `--confirm` for every setup invocation that changes files, installs packages, uses the network, or calls `sudo`. 2. Do not treat a local-package path as consent for unrelated installation steps. 3. Split setup into independently authorized components such as `--install-python-deps`, `--install-xvfb`, `--install-oda`, and `--install-qcad`. 4. Display an exact execution plan before making changes and require confirmation for that plan. 5. Make local-package modes install only the explicitly selected artifact unless the user separately authorizes dependencies. 6. Avoid system-wide `pip3` installation; use an isolated virtual environment. 7. Check effective privileges and minimize the number and scope of `sudo` commands. 8. Update the documentation so the consent behavior exactly matches the executable implementation. ]]>

T08 · Insecure Dependencies

Error
Location
scripts/setup.sh:164
Finding
Downloaded ODA and QCAD Components Are Installed Without Integrity Verification<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:164-192` and `scripts/setup.sh:248-273` **Vulnerability Type**: Unverified third-party binary installation **Risk Level**: High ### Vulnerable Code ```bash # Attempt automatic download log_info "Attempting to automatically download ODA File Converter..." # ODA official site requires registration, here we provide common download URL patterns ODA_URLS=( "https://download.opendesign.com/guestfiles/ODAFileConverter/ODAFileConverter_QT6_lnxX64_8.3dll_25.3.rpm" "https://download.opendesign.com/guestfiles/ODAFileConverter/ODAFileConverter_QT6_lnxX64_8.3dll_25.3.deb" ) ODA_DOWNLOADED=false TMP_DIR=$(mktemp -d) for url in "${ODA_URLS[@]}"; do FILENAME=$(basename "$url") log_info "Attempting download: $FILENAME" if wget -q --timeout=30 -O "$TMP_DIR/$FILENAME" "$url" 2>/dev/null || \ curl -sL --connect-timeout 30 -o "$TMP_DIR/$FILENAME" "$url" 2>/dev/null; then if [ -s "$TMP_DIR/$FILENAME" ]; then EXT="${FILENAME##*.}" if [ "$EXT" = "rpm" ]; then sudo rpm -i --replacefiles --nodeps "$TMP_DIR/$FILENAME" 2>/dev/null && ODA_DOWNLOADED=true elif [ "$EXT" = "deb" ]; then sudo dpkg -i "$TMP_DIR/$FILENAME" 2>/dev/null && ODA_DOWNLOADED=true fi if [ "$ODA_DOWNLOADED" = true ]; then log_ok "ODA File Converter installed successfully" break fi fi fi done ``` ```bash # Auto-download QCAD Trial (includes dwg2bmp) log_info "Attempting to automatically download QCAD Professional Trial..." QCAD_URLS=( "https://www.qcad.org/archives/qcad/qcad-3.32.6-trial-linux-x86_64.tar.gz" "https://www.qcad.org/archives/qcad/qcad-3.32.5-trial-linux-x86_64.tar.gz" "https://www.qcad.org/archives/qcad/qcad-3.32.4-trial-linux-x86_64.tar.gz" ) TMP_DIR=$(mktemp -d) QCAD_DOWNLOADED=false for url in "${QCAD_URLS[@]}"; do FILENAME=$(base ...[truncated 2597 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin every supported artifact to an exact version and independently obtained SHA-256 or stronger digest. 2. Verify RPM and DEB vendor signatures against explicitly trusted signing keys before installation. 3. Abort setup on any checksum, signature, filename, architecture, or version mismatch. 4. Publish a reviewed manifest containing expected URLs, sizes, hashes, and signatures. 5. Prefer distribution repositories with package-signature enforcement over direct privileged package installation. 6. Remove `--nodeps` and preserve package-manager dependency and signature checks. 7. Download first, verify completely, show verification results to the user, and only then request authorization for installation. 8. Run downloaded user-space tools in a restricted sandbox with minimal filesystem and network access. ]]>

T08 · Insecure Dependencies

Warning
Location
scripts/setup.sh:108
Finding
Unpinned Python Dependencies Are Installed from the Active Package Index<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:108-120` **Vulnerability Type**: Unpinned dependency installation **Risk Level**: Medium ### Vulnerable Code ```bash install_python_pkg() { local pkg=$1 if python3 -c "import $pkg" 2>/dev/null; then log_ok "$pkg already installed" else log_info "Installing $pkg ..." pip3 install "$pkg" -q && log_ok "$pkg installed successfully" || log_err "$pkg installation failed" fi } install_python_pkg ezdxf install_python_pkg matplotlib ``` ### Technical Analysis The setup process installs `ezdxf` and `matplotlib` without version constraints or cryptographic hashes. The selected packages therefore depend on the active `pip` configuration, configured index URLs, and newest compatible releases available when setup runs. Although the package names are legitimate and no dependency-confusion package is directly identified in the audited files, the installation process lacks reproducibility and supply-chain integrity controls. Python packages and their transitive dependencies may execute build or installation code, and their imported runtime code executes with the privileges of the invoking user. ### Attack Path 1. An attacker compromises a configured package index, a package release, a transitive dependency, or the user's `pip` index configuration. 2. The user runs the assisted setup process. 3. `pip3 install` resolves an attacker-controlled or compromised release because no version or hash is pinned. 4. Malicious installation hooks, build logic, or imported package code executes. 5. The attacker gains code execution with the privileges of the user running setup. ### Impact Assessment Successful exploitation grants code execution under the setup user's account. If setup is launched from a privileged shell, the impact may be elevated accordingly. The malicious package can access files, credentials, environment variables, and network resources available to that ...[truncated 110 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Create a reviewed dependency lock file with exact versions for direct and transitive dependencies. 2. Record cryptographic hashes and install with `pip --require-hashes`. 3. Use an isolated virtual environment rather than the system Python environment. 4. Configure a trusted package index explicitly instead of inheriting arbitrary user or system index settings. 5. Periodically scan locked dependencies for known vulnerabilities and review updates before changing versions. 6. Disable source builds where feasible and prefer reviewed, hash-pinned wheels for the supported platform. 7. Document the dependency update and verification process. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/setup.sh:241
Finding
QCAD Archives Are Extracted Without Validating Archive Entries<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup.sh:241-246` and `scripts/setup.sh:256-270` **Vulnerability Type**: Unsafe archive extraction **Risk Level**: Medium ### Vulnerable Code ```bash if [ -n "$QCAD_TAR_PATH" ] && [ -f "$QCAD_TAR_PATH" ]; then # User provided local tar.gz package log_info "Installing QCAD using local tar.gz package: $QCAD_TAR_PATH" mkdir -p "$QCAD_INSTALL_DIR" tar -xzf "$QCAD_TAR_PATH" -C "$QCAD_INSTALL_DIR" --strip-components=1 2>/dev/null ``` ```bash TMP_DIR=$(mktemp -d) QCAD_DOWNLOADED=false for url in "${QCAD_URLS[@]}"; do FILENAME=$(basename "$url") log_info "Attempting download: $FILENAME" if wget -q --timeout=60 -O "$TMP_DIR/$FILENAME" "$url" 2>/dev/null || \ curl -sL --connect-timeout 60 -o "$TMP_DIR/$FILENAME" "$url" 2>/dev/null; then if [ -s "$TMP_DIR/$FILENAME" ]; then mkdir -p "$QCAD_INSTALL_DIR" tar -xzf "$TMP_DIR/$FILENAME" -C "$QCAD_INSTALL_DIR" --strip-components=1 2>/dev/null if [ -f "$QCAD_INSTALL_DIR/dwg2bmp" ]; then QCAD_DOWNLOADED=true log_ok "QCAD extracted successfully" break fi fi fi done ``` ### Technical Analysis Both local and remotely downloaded archives are passed directly to `tar` without first inspecting their member paths or types. The script does not reject absolute paths, parent-directory traversal, symbolic links, hard links, device files, unexpected ownership metadata, or files outside an expected manifest. The extraction occurs directly into the persistent Skill assets directory rather than a disposable staging directory. Security consequences depend on the `tar` implementation and archive construction, but unsafe archive entries and link chains can cause writes outside the intended logical package layout. At minimum, an attacker can provide a substituted executable named `dwg2bmp`, which the script marks executable and the P ...[truncated 1147 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. List and validate all archive members before extraction. 2. Reject absolute paths, paths containing `..`, symbolic links, hard links, device nodes, FIFOs, and unexpected file types. 3. Require every normalized destination path to remain under a newly created staging directory. 4. Extract as an unprivileged user with restrictive permissions and without preserving archive ownership. 5. Verify the archive hash and signed manifest before processing it. 6. Validate the expected directory structure and executable hashes after extraction. 7. Move verified files atomically from the staging directory into the final installation directory. 8. Refuse to overwrite an existing installation unless the user explicitly authorizes a verified upgrade. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (46)

Tool Parameter Abuse

High
Category
Tool Misuse
Content
Delete the marker file to re-run full installation on next execution:

```bash
rm assets/.setup_done
```

**Poor screenshot quality**
Confidence
85% confidence
Finding
Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Intent-Code Divergence

High
Confidence
98% confidence
Finding
The document says the tool does not automatically install packages, but later states that the first run may automatically install dependencies and create a setup marker. Contradictory installation behavior is dangerous because users and agents may believe analysis is read-only while triggering package installs, downloads, or privileged setup actions.

Ae1

High
Category
analysis-evasion
Content
scripts/cad_tools.py
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Chaining Abuse

High
Category
Tool Misuse
Content
else
    log_info "Installing xvfb ..."
    if [ "$PKG_MANAGER" = "apt-get" ]; then
        sudo apt-get update -qq && sudo apt-get install -y -qq xvfb
    else
        sudo $PKG_MANAGER install -y xorg-x11-server-Xvfb 2>/dev/null || \
        sudo $PKG_MANAGER install -y Xvfb 2>/dev/null || \
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Chaining Abuse

High
Category
Tool Misuse
Content
sudo rpm -i --replacefiles --nodeps "$ODA_RPM_PATH" 2>/dev/null || \
            sudo $PKG_MANAGER localinstall --skip-broken -y "$ODA_RPM_PATH" 2>/dev/null
        elif [ "$EXT" = "deb" ]; then
            sudo dpkg -i "$ODA_RPM_PATH" 2>/dev/null || sudo apt-get install -f -y 2>/dev/null
        fi
    else
        # Attempt automatic download
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS supported)
- **Python**: 3.8+ (system installed, other deps auto-installed)
- **Permissions**: root or sudo (required for installing system packages on first setup)

> macOS / Windows not supported (ODA File Converter and QCAD are Linux x86_64 only)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS supported)
- **Python**: 3.8+ (system installed, other deps auto-installed)
- **Permissions**: root or sudo (required for installing system packages on first setup)

> macOS / Windows not supported (ODA File Converter and QCAD are Linux x86_64 only)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS supported)
- **Python**: 3.8+ (system installed, other deps auto-installed)
- **Permissions**: root or sudo (required for installing system packages on first setup)

> macOS / Windows not supported (ODA File Converter and QCAD are Linux x86_64 only)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS supported)
- **Python**: 3.8+ (system installed, other deps auto-installed)
- **Permissions**: root or sudo (required for installing system packages on first setup)

> macOS / Windows not supported (ODA File Converter and QCAD are Linux x86_64 only)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS supported)
- **Python**: 3.8+ (system installed, other deps auto-installed)
- **Permissions**: root or sudo (required for installing system packages on first setup)

> macOS / Windows not supported (ODA File Converter and QCAD are Linux x86_64 only)
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Vague Triggers

Medium
Confidence
96% confidence
Finding
The README states the skill auto-triggers whenever DWG/DXF/CAD drawings are mentioned, which is a broad activation condition for an agent-integrated skill. Over-broad triggering can cause the agent to invoke file-analysis and setup-related capabilities in conversations that merely mention CAD terms, increasing the chance of unintended tool use and exposure to risky follow-on actions such as environment setup or external dependency installation.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Permission errors on first run**

setup.sh requires root permissions to install system packages. Please run as root or via sudo.

**ODA automatic download fails**
Confidence
80% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
## System Requirements
- **OS**: Linux x86_64 (Ubuntu/Debian/RHEL/CentOS)
- **Python**: 3.8+
- **Permissions**: root/sudo (required for installing system packages on first run)

## External Dependencies
This Skill depends on the following external tools (auto-installed by setup.sh):
Confidence
83% confidence
Finding
The document declares root/sudo as a requirement for installing packages and references auto-installation via setup.sh. While not inherently malicious, normalizing privileged execution for a skill materially raises risk because any flaw in the installer, dependency source, or future update path can lead to arbitrary system-wide changes or full host compromise.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The release notes explicitly state that the skill auto-installs external dependencies and requires root/sudo on first run, but they do not provide a clear warning, consent flow, or controls around system modification. In a skill ecosystem, encouraging privileged setup from bundled scripts increases supply-chain and host-compromise risk if the script or downloaded binaries are tampered with or behave unexpectedly.

Lp3

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding
The skill exposes shell, file read, and environment-sensitive behavior but does not declare any explicit tool scope or restrictions. That makes it easier for an agent to invoke broader capabilities than users would reasonably expect from a CAD viewer, increasing the chance of unintended command execution or filesystem access.

Vague Triggers

Medium
Confidence
93% confidence
Finding
The trigger list in the manifest includes generic terms such as "layer," "block," "entity," and "screenshot," plus "or any mention of .dwg/.dxf files." Several of these words are common outside this specific skill context, which makes invocation scope ambiguous and increases the risk of unintended activation.

Unrestricted Tool Access

Medium
Category
Excessive Agency
Content
- The `{SKILL_DIR}` placeholder refers to the directory containing this SKILL.md file
- **First run may take 1-3 minutes** as the tool automatically installs all dependencies
- After first setup, a marker file is created at `assets/.setup_done` to skip future setup
- To re-run setup (e.g. after system update), delete `assets/.setup_done` and run any command
- DWG files require ODA File Converter for reading; DXF files can be read directly
- Screenshot quality is best with QCAD dwg2bmp; matplotlib is a reasonable fallback
- Large drawings may take several seconds to load — this is normal for complex engineering files
Confidence
81% confidence
Finding
The documented behavior implies that running ordinary commands may trigger setup-related side effects, while no tight tool boundaries are declared. In context, this broad execution model is risky because a seemingly simple CAD operation could invoke shell actions, installers, or other unintended commands.

Description-Behavior Mismatch

Medium
Confidence
95% confidence
Finding
The manifest presents a CAD analysis utility, but the documentation adds persistent self-learning reads and writes in the user's project. This is a scope expansion not justified by the advertised function and creates hidden stateful behavior that can collect and reuse project-derived data across sessions.

Context-Inappropriate Capability

Medium
Confidence
95% confidence
Finding
A persistent cross-session memory mechanism in `.learning/` is not necessary for a CAD viewer's core purpose and creates durable storage of user and project context. This can lead to data retention, unintended disclosure, and behavior influenced by stale or unrelated prior project information.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The self-learning feature instructs the agent to create and write project files automatically, but the nearby behavior description does not provide a prominent, explicit warning or consent gate. Silent modification of the user's workspace is risky because it persists data locally and can surprise users who expected read-only analysis.

Ssd 3

Medium
Confidence
95% confidence
Finding
Mandatory review and reuse of `.learning/` files at the start of every task creates a built-in cross-session data retention channel. Even without obvious secrets, project-specific notes, prior errors, and preferences can leak context across tasks and influence future behavior in ways users did not request.

Ssd 3

Medium
Confidence
96% confidence
Finding
The logging guidance broadly instructs the agent to record corrections, preferences, errors, and discovered context into local files. That creates a durable repository of potentially sensitive project and user-derived information that may later be exposed to other sessions, tools, or collaborators with filesystem access.

Ae4

Medium
Category
analysis-evasion
Confidence
80% confidence
Finding
Suspicious Unicode normalization or mixed-script content

Natural-Language Policy Violations

Medium
Confidence
95% confidence
Finding
Nearly all docstrings, CLI descriptions, help messages, and errors are presented only in Chinese. This imposes a fixed language/locale on all users without opt-in, which matches the policy category for language or locale constraints.

Dynamic import via __import__()

Medium
Category
Dangerous Code Execution
Content
missing = []
    for pkg in ("ezdxf", "matplotlib"):
        try:
            __import__(pkg)
        except ImportError:
            missing.append(pkg)
Confidence
75% confidence
Finding
Dynamic __import__() can load arbitrary modules at runtime, bypassing static analysis and potentially importing malicious code.

Static analysis

No suspicious patterns detected.