Back to skill

Security audit

CADStack - CAD Automation Skill Pack

Security checks for vulnerabilities and agentic risk

Overview

This CAD automation skill is not clearly malicious, but it asks agents to run generated local Python and exposes CAD applications with weak safety boundaries.

Install only if you trust the publisher and can run it in a constrained local CAD environment. Review generated scripts before running them, avoid the Fusion 360 bridge until it has authentication or per-request approval, restrict output paths, and do not run the documented remote setup command unless it points to a verified pinned release.

Vulnerability Patterns
  • 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
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (4)

T09 · Insecure Skill Coding Practices

Error
Location
lib/cad_executor.py:155
Finding

Generated Python Scripts Execute in a Bypassable In-Process Sandbox

Content
View full analysis

Vulnerability Details

File Location: lib/cad_executor.py:155-194; supporting validation logic in lib/utils/helpers.py:124-263
Vulnerability Type: In-process execution of untrusted Python with an incomplete deny-list sandbox
Risk Level: Critical

Vulnerable Code

python
script_content = script.read_text(encoding='utf-8')

# Validate script (STRICT - blocks on dangerous patterns)
if validate:
    from lib.utils.helpers import CADScriptValidator
    is_safe, errors = CADScriptValidator.validate_strict(script_content)
    if not is_safe:
        console.print("[red]Script validation FAILED - dangerous patterns detected:[/red]")
        for error in errors:
            console.print(f"  [red]✗[/red] {error}")
        console.print("\n[yellow]Script execution blocked for security.[/yellow]")
        raise typer.Exit(1)

# Get backend
try:
    backend = get_backend(platform)
    console.print(f"[green]Backend initialized: {backend.name}[/green]")
except BackendNotAvailableError as e:
    console.print(f"[red]{e}[/red]")
    if e.hint:
        console.print(f"[yellow]{e.hint}[/yellow]")
    raise typer.Exit(1)

# Prepare execution namespace (SANDBOXED)
output_path = output or (Path.cwd() / f"output.{format}")
output_path.parent.mkdir(parents=True, exist_ok=True)

# Restricted namespace - only safe utilities
safe_namespace = {
    'backend': backend,
    'output': output_path,
    'format': format,
    'Path': Path,
    # No console, no builtins access
}

# Execute script
console.print(f"\n[cyan]Executing script...[/cyan]")
try:
    exec(script_content, {"__builtins__": {}}, safe_namespace)

The validator relies on regular-expression and AST deny-lists:

python
def visit_Call(self, node):
    # Check for dangerous function calls
    if isinstance(node.func, ast.Name):
        dangerous_funcs = {
            'eval', 'exec', 'compile', '__import_
...[truncated 2386 chars]
Remediation
View remediation

Remediation Suggestions

  1. Remove in-process execution of generated Python.
  2. Represent CAD operations using a declarative format such as JSON with a strict schema, fixed operation names, numeric limits, and explicitly validated arguments.
  3. Dispatch validated operations through trusted application code rather than exec().
  4. If Python execution is unavoidable, run it in a separate disposable container or sandboxed process with:
    • No network access.
    • A read-only root filesystem.
    • A dedicated writable output directory.
    • A non-privileged UID.
    • CPU, memory, process, and execution-time limits.
    • A restrictive syscall policy.
    • No inherited credentials or sensitive environment variables.
  5. Remove the --no-validate option from normal production interfaces.
  6. Replace deny-list validation with a small positive allow-list of permitted AST node types and backend methods. Treat this only as defense in depth, not as the primary security boundary.
  7. Add adversarial tests for indirect attribute traversal, inherited-class discovery, callable retrieval, malformed AST constructs, resource exhaustion, and filesystem escape attempts.

T09 · Insecure Skill Coding Practices

Error
Location
lib/backends/autocad.py:211
Finding

AutoCAD Command Injection Through an Unescaped Export Path

Content
View full analysis

Vulnerability Details

File Location: lib/backends/autocad.py:211-252
Vulnerability Type: Command injection into the AutoCAD command interpreter
Risk Level: High

Vulnerable Code

python
def export(self, doc: CADDocument, filepath: Path, format: str = "step") -> bool:
    """Export document to file.

    Args:
        doc: Document to export
        filepath: Output file path
        format: Export format (step, stl, sat, dwg)

    Returns:
        True if export succeeded
    """
    try:
        filepath = Path(filepath)

        # Map format to AutoCAD export type
        format_map = {
            "step": "STEP",
            "stp": "STEP",
            "stl": "STL",
            "sat": "SAT",
            "dwg": "DWG",
            "dxf": "DXF"
        }

        acad_format = format_map.get(format.lower(), format.upper())

        # Try Export command first (newer AutoCAD)
        try:
            self._doc.Export(str(filepath), acad_format)
            return True
        except:
            pass

        # Fallback to SendCommand for older versions
        command = f'_EXPORT "{filepath}" '
        if acad_format == "STEP":
            command = f'_STEP "{filepath}"'
        elif acad_format == "STL":
            command = f'_STLOUT "{filepath}"'

        self._doc.SendCommand(command + "\n")
        return True

    except Exception as e:
        print(f"Export failed: {e}")
        return False

Technical Analysis

The output path is caller-controlled through the executor’s --output option and is interpolated directly into an AutoCAD command string. The implementation does not reject or escape quotation marks, line breaks, semicolons, or other characters meaningful to the AutoCAD command processor.

The unsafe path is used whenever the initial typed COM Export operation raises an exception. The broad bare except silently enters ...[truncated 1198 chars]

Remediation
View remediation

Remediation Suggestions

  1. Remove the textual SendCommand fallback and use typed COM export APIs exclusively.
  2. Fail securely if the typed export operation is unavailable instead of silently changing to a command interpreter.
  3. Canonicalize export paths and require them to remain beneath an explicitly configured output directory.
  4. Reject control characters, quotation marks, command delimiters, and unexpected path syntax.
  5. Apply a strict filename allow-list and a format allow-list rather than passing arbitrary format strings.
  6. Catch specific COM exceptions and log the reason that the typed export failed.
  7. Add tests using paths containing quotes, newlines, Unicode separators, relative traversal components, and AutoCAD command delimiters.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
lib/bridge/fusion360_bridge.py:13
Finding

Fusion 360 Bridge Accepts Unauthenticated Local Control Requests

Content
View full analysis

Vulnerability Details

File Location: lib/bridge/fusion360_bridge.py:13-105; arbitrary export path handling at lib/bridge/fusion360_bridge.py:557-580
Vulnerability Type: Missing authentication and authorization on a privileged local CAD control service
Risk Level: High

Vulnerable Code

python
# Configuration
HOST = 'localhost'
PORT = 8080
BUFFER_SIZE = 4096

class Fusion360Bridge:
    """Bridge between Fusion 360 and CADStack."""

    def __init__(self):
        self.app = adsk.core.Application.get()
        self.ui = self.app.userInterface
        self.running = False
        self.server_socket = None

    def start(self):
        """Start the bridge server."""
        try:
            self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            self.server_socket.bind((HOST, PORT))
            self.server_socket.listen(1)
            self.server_socket.settimeout(1.0)  # Allow checking running flag

            self.running = True
            self.ui.messageBox(f'CADStack Bridge started on port {PORT}')

            # Start server thread
            thread = threading.Thread(target=self._server_loop)
            thread.daemon = True
            thread.start()
python
def _server_loop(self):
    """Main server loop."""
    while self.running:
        try:
            self.server_socket.settimeout(0.5)
            client_socket, address = self.server_socket.accept()

            # Handle request
            data = client_socket.recv(BUFFER_SIZE)
            if data:
                request = json.loads(data.decode('utf-8'))
                response = self._handle_request(request)
                client_socket.sendall((json.dumps(response) + '\n').encode('utf-8'))

            client_socket.close()
python
def _handle_reques
...[truncated 3647 chars]
Remediation
View remediation

Remediation Suggestions

  1. Prefer an operating-system IPC mechanism that supports peer identity and restrictive permissions.
  2. If TCP must be retained, generate a cryptographically random per-session token and authenticate every request.
  3. Store the token with user-only permissions and never expose it through logs or user-visible error messages.
  4. Add request authorization so only explicitly enabled actions are accepted.
  5. Require user confirmation for destructive operations and exports that may overwrite an existing file.
  6. Canonicalize export paths and constrain them to a configured output directory.
  7. Define and enforce a strict JSON schema, including numeric bounds, string-length limits, and permitted action names.
  8. Limit request size, apply timeouts and rate limits, and ensure sockets are closed in finally blocks.
  9. Record security-relevant connection and action metadata without logging sensitive tokens.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:87
Finding

Installation Documentation Executes an Unpinned Remote Setup Payload

Content
View full analysis

Vulnerability Details

File Location: SKILL.md:87-91; duplicate instructions in README.md:13-21
Vulnerability Type: Mutable and unverifiable software supply-chain installation
Risk Level: Medium

Vulnerable Code

SKILL.md instructs users to clone a mutable placeholder repository and immediately run its setup payload:

bash
# Install cadstack
git clone https://github.com/user/cadstack.git ~/.claude/skills/cadstack
cd ~/.claude/skills/cadstack && ./setup

README.md contains a different placeholder repository and setup invocation:

bash
# Clone the repository
git clone https://github.com/yourusername/cadstack.git ~/.claude/skills/cadstack

# Run setup
cd ~/.claude/skills/cadstack
python setup

Technical Analysis

The instructions do not pin a commit, immutable release, checksum, signature, or verified publisher identity. Both repository owner names are placeholders, and the two documents disagree about the repository URL and how the setup payload is executed.

The audited project tree does not contain the referenced setup file. Consequently, the installation step causes users to execute code that is outside the reviewed artifact. Because the cloned default branch is mutable, its effective payload can change after this audit without any change to the reviewed documentation.

This is a supply-chain weakness rather than evidence that the current artifact itself retrieves and runs a malicious payload automatically. Exploitation requires a user to follow or adapt the documented installation commands.

Attack Path

  1. A user follows the installation documentation or substitutes a repository believed to be the intended project.
  2. Git clones the current contents of a mutable remote default branch.
  3. The user immediately invokes ./setup or python setup.
  4. The setup file executes with the user’s account privileges.
  5. A compromised, reassigned, or attacker ...[truncated 576 chars]
Remediation
View remediation

Remediation Suggestions

  1. Replace all placeholder URLs with one verified canonical repository.
  2. Publish signed, immutable releases and instruct users to install a specific release or commit hash.
  3. Provide SHA-256 checksums or cryptographic signatures for release artifacts and document verification steps.
  4. Include the setup script in the reviewed project so its behavior can be audited.
  5. Make installation instructions consistent across README.md and SKILL.md.
  6. Avoid immediately executing code from a freshly cloned mutable branch.
  7. Document every dependency and pin compatible versions using a lock file or hashes.
  8. Ensure the installer operates with normal user privileges and clearly prompts before making persistent environment or profile changes.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (33)

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
91% confidence
Finding

The --no-validate flag allows callers to bypass the only application-level protection intended to block dangerous script patterns before execution. Because the same command then feeds the script to exec(), this option materially lowers the barrier to executing malicious CAD/Python payloads, especially in automated agent or tool-chaining contexts where parameters may be attacker-influenced.

Content

Scanner excerpt · lib/cad_executor.py (reported line 140)May include surrounding context.

python
help="CAD platform (cadquery, freecad, autocad, solidworks, fusion360)"),
    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output file path"),
    format: str = typer.Option("step", "--format", "-f", help="Output format (step, stl, obj)"),
    validate: bool = typer.Option(True, "--validate/--no-validate", help="Validate script before execution"),
    verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
):
    """Execute a CAD script on the specified platform."""

exec() call detected

High
Category
Dangerous Code Execution
Confidence
97% confidence
Finding

The run command executes attacker-controlled script content via exec(). Although builtins is emptied, this is not a reliable sandbox in Python, and the script is also given live objects such as backend, Path, output, and format that can be abused for side effects or leveraged in sandbox-escape techniques. In this skill context, executing user-supplied CAD scripts is central functionality, which makes the risk more dangerous rather than less because hostile input is an expected use case.

Content

Scanner excerpt · lib/cad_executor.py (reported line 194)May include surrounding context.

python
# Execute script
    console.print(f"\n[cyan]Executing script...[/cyan]")
    try:
        exec(script_content, {"__builtins__": {}}, safe_namespace)
        console.print(f"\n[green]Script executed successfully[/green]")
        console.print(f"Output: {output_path}")
    except CADStackError as e:

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Confidence
75% confidence
Finding

YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

Content

Scanner excerpt · skills/cad-config.md (reported line 154)May include surrounding context.

ecutor.py check freecad

text

## Platform-Specific Setup

### FreeCAD (Recommended)

**Prerequisites:**
- FreeCAD 0.20+ installed
- Python 3.8+

**Installation:**
```bash
# Ubuntu/Debian
sudo apt install freecad

# macOS
brew install --cask freecad

# Windows
# Download from https://www.freecad.org/downloads.php

Configuration:

bash
# Add to PYTHONPATH (choose appropriate path)

# Linux
echo 'export PYTHONPATH=/usr/lib/freecad/lib:$PYTHONPATH' >> ~/.bashrc

# macOS (Apple Silicon)
echo 'export PYTHONPATH=/Applications/FreeCAD.app/Contents/lib:$PYTHONPATH' >> ~/.zshrc

# Windows - set via System Properties > Environment Variables

AutoCAD

Prerequisites:

  • AutoCAD 2020+ installed and licensed
  • Windows OS
  • pywin32 package

Installation:

bash
pip install pywin32

Configuration:

  1. Ensure AutoCAD is running
  2. Run /cad-config --check autocad to verify connection

SolidWorks

Prerequisites:

  • SolidWorks 2020+ installed and licensed
  • Windows

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
90% 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).

Content

Scanner excerpt · skills/cad-review.md (reported line 15)May include surrounding context.

python
# DANGEROUS - Should reject or warn
os.system("rm -rf /")
subprocess.call(["dangerous", "command"])
eval(user_input)
exec(untrusted_code)

Tool Parameter Abuse

High
Category
Tool Misuse
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).

Content

Scanner excerpt · skills/cad-review.md (reported line 15)May include surrounding context.

python
# DANGEROUS - Should reject or warn
os.system("rm -rf /")
subprocess.call(["dangerous", "command"])
eval(user_input)
exec(untrusted_code)

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · README.md (reported line 9)May include surrounding context.

md
- **Multi-platform support**: FreeCAD, AutoCAD, SolidWorks, Fusion 360
- **Headless mode**: FreeCAD works without GUI
- **Natural language control**: Create parts using conversational commands
- **Script templates**: Pre-built templates for common parts
- **Safety review**: Built-in script validation before execution

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · README.md (reported line 38)May include surrounding context.

bash
# In Claude Code
/cad "Create a 100x50x20mm box with 5mm fillets"
/cad "Create a gear with 20 teeth, module 2"
/cad "Create a mounting bracket with 4 holes"

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · SKILL.md (reported line 96)May include surrounding context.

Then in Claude Code:

text
/cad "Create a 100x50x20mm box with 5mm filleted edges"

First Run Experience

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The solver claims to enforce constraints between specific geometric features, but the implementation ignores actual feature geometry and instead applies simplistic position/rotation changes. In a CAD or engineering workflow, this can silently produce assemblies that appear solved but are physically or dimensionally incorrect, creating integrity and safety risks if downstream automation trusts the result.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
98% confidence
Finding

The docstring on export_step says "Export to STEP format," but the implementation calls self._doc.Export(str(filepath), "SAT"), which exports ACIS SAT instead of STEP. This is an active contradiction between the documented intent and the actual operation.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
88% confidence
Finding

These methods trigger file exports to user-specified paths, which are file-write operations that can affect local data and system state. While the docstrings describe the format, there is no confirmation prompt, logging, or explicit user-facing warning in this file about writing files to disk.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The add-in opens a local socket server and accepts unauthenticated JSON commands that can create, modify, and export Fusion 360 data with no per-request user approval. Even though it binds to localhost, any local process or malware running as the user can drive the CAD application, alter active designs, and trigger data export, making this a real unauthorized-action surface.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The export handler accepts an arbitrary filepath from the socket request and writes design output there without validation or user confirmation. A local attacker can exfiltrate sensitive CAD data by exporting to attacker-controlled locations or overwrite user-accessible files in unintended paths, especially because the bridge already exposes this capability over an unauthenticated local socket.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The code describes execution as 'SANDBOXED' and 'only safe utilities' while exposing a fully capable backend object and filesystem paths to the executed script. That can mislead operators into trusting a boundary that does not actually prevent side effects such as file creation, CAD automation actions, or potentially broader abuse depending on backend capabilities. Misrepresenting the security model increases the likelihood of unsafe deployment and use.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
81% confidence
Finding

This code creates directories, selects a default output path, executes user-provided script content, and reports success, but it does not provide a specific safety disclosure that running the script will generate or overwrite files on disk. The generic execution banner and success output are operational messages, not a warning about file-system effects of executing untrusted or user-supplied CAD scripts.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
97% confidence
Finding

The docstring and examples describe generating a drawing from the supplied STEP/STL file, but the implementation never loads or parses the file contents. Instead, it calls set_model(None, bounds=(0, 0, 0, 100, 100, 50)), so the produced drawing is not actually derived from the input model.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
60% confidence
Finding

Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Content

Scanner excerpt · skills/cad-config.md (reported line 25)May include surrounding context.

2. Set Default Platform

Create or update ~/.claude/skills/cadstack/config.json:

json
{

Sudo/Root Execution

Medium
Category
Privilege Escalation
Confidence
70% confidence
Finding

Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Content

Scanner excerpt · skills/cad-config.md (reported line 140)May include surrounding context.

Installation:

bash
# Ubuntu/Debian
sudo apt install freecad

# macOS
brew install --cask freecad

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The skill explicitly instructs the agent to "generate and run scripts" for CAD operations, but it does not require a user-facing warning, confirmation, or safety boundary before execution. Even if the intended action is normal CAD automation, executing generated scripts can modify files, CAD models, exports, or connected environments, so silent execution increases the risk of unintended system-changing actions.

Content

No source excerpt is available for this finding.

Session Persistence

Medium
Category
Rogue Agent
Confidence
70% confidence
Finding

The workflow introduces a generate-review-execute pipeline that can persist generated scripts and produced files across the session, including in a fixed output directory under the user's home directory. In context, persistence is risky because later steps may trust or reuse prior artifacts, and generated scripts or outputs could expose sensitive design data or be tampered with between review and execution if lifecycle controls are weak.

Content

Scanner excerpt · skills/cad.md (reported line 23)May include surrounding context.

md
- Transformations (move, rotate)
   - Export format (STEP, STL, OBJ)

2. **Generate Script**: Create platform-specific Python script using the backend API

3. **Safety Review**: Check for dangerous patterns (built-in /cad-review behavior)

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
91% confidence
Finding

The skill explicitly tells the agent to generate and execute Python scripts, but it does not require explicit user consent, constrain the script surface, or warn that local code execution and file creation will occur. Because the script content is derived from natural-language requests, prompt-influenced code generation can lead to unsafe operations, unintended filesystem changes, or abuse of the execution environment if guardrails are bypassed or incomplete.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
99% confidence
Finding

The inline comment on L10 states the code exports to SAT format, but the actual call on L11 is backend.export_step(...), which indicates STEP export instead. This is an active contradiction between documentation and behavior, not merely omitted detail.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The file advertises a parametric involute gear, but the implemented geometry is only an extruded circle or fallback cylinder, not a toothed gear. This can mislead downstream users into trusting exported CAD as mechanically correct, causing design, fit, or safety failures when the part is manufactured or used in assemblies.

Content

No source excerpt is available for this finding.

Intent-Code Divergence

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

The inline comments suggest gear construction, but the code creates a circular face and extrudes it into a solid disk, with no toothed profile applied. In a CAD automation context, this discrepancy is dangerous because users may fabricate or integrate a part they believe is a functional gear when it is not.

Content

No source excerpt is available for this finding.

Missing User Warnings

Low
Category
Not specified by scanner
Confidence
89% confidence
Finding

This is a markdown file, so SQP-2 applies to whether the skill description warns about behaviors affecting user data or system state. The README documents export operations that create files, but it does not include any caution that running these commands will write CAD artifacts to disk or may overwrite existing files depending on the chosen path.

Content

No source excerpt is available for this finding.

Static analysis

No suspicious patterns detected.