Back to skill

Security audit

Agent Factory

Security checks for vulnerabilities and agentic risk

Overview

This skill fits its agent-factory purpose, but it exposes powerful local factory operations with weak access control and broken safety gates that need review before installation.

Install only in a tightly isolated workspace and do not expose the dashboard to a network until authentication, localhost binding, path containment, archive validation, real benchmarking, and secret-key handling are fixed. Expect prompt/task content to be stored locally and possibly sent to configured LLM or webhook endpoints.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
skills/agent-factory/dashboard/app.py:85
Finding

Unauthenticated Network API Exposes Privileged Agent-Factory Operations

Content
View full analysis

Vulnerability Details

File Location: skills/agent-factory/dashboard/app.py, lines 85–141 and 180–181
Vulnerability Type: Missing authentication and authorization on state-changing API endpoints
Risk Level: High

Vulnerable Code

python
def do_POST(self):
    parsed = urlparse(self.path)
    path = parsed.path

    content_length = int(self.headers.get("Content-Length", 0))
    body = self.rfile.read(content_length) if content_length > 0 else b"{}"

    try:
        payload = json.loads(body.decode("utf-8")) if body else {}
    except Exception:
        payload = {}

    if path == "/api/route":
        prompt = payload.get("prompt", "").strip()
        if not prompt:
            self._set_headers("application/json", 400)
            self.wfile.write(json.dumps({"error": "Prompt cannot be empty"}).encode("utf-8"))
            return
        result = route_and_execute(prompt)
        self._set_headers("application/json")
        self.wfile.write(json.dumps(result).encode("utf-8"))

    elif path == "/api/evolve-prompt":
        base_prompt = payload.get("prompt", "Tu es un agent spécialisé.")
        domain = payload.get("domain", "general")
        generations = payload.get("generations", 3)
        evolved = evolve_prompt(base_prompt, domain, generations=generations)
        self._set_headers("application/json")
        self.wfile.write(json.dumps(evolved).encode("utf-8"))

    elif path == "/api/execute-dag":
        tasks = payload.get("tasks", [])
        nodes = [TaskNode(t["id"], t["prompt"], t.get("depends_on", [])) for t in tasks]
        coordinator = DAGCoordinator()
        dag_result = coordinator.execute_dag(nodes)
        self._set_headers("application/json")
        self.wfile.write(json.dumps(dag_result).encode("utf-8"))

    elif path == "/api/trigger-cycle":
        clusters = analyze_clusters()
        if not clusters:
            discover_clusters(min_cluster_size=2)
            clusters = analyze_clusters(min_occurrenc
...[truncated 2925 chars]
Remediation
View remediation

Remediation Suggestions

  • Bind the dashboard to 127.0.0.1 by default and require an explicit configuration option for remote exposure.
  • Require strong authentication for every API endpoint, such as a securely generated bearer token or authenticated session.
  • Enforce endpoint-specific authorization. Factory lifecycle operations should be restricted to an administrative role.
  • Add CSRF protection if cookie-based browser authentication is used.
  • Disable state-changing endpoints by default unless factory administration is explicitly enabled.
  • Apply request size limits, rate limits, execution quotas, and schema validation to workload endpoints.
  • Place the service behind TLS and a trusted reverse proxy when remote access is required.
  • Return CORS headers only for explicitly trusted origins rather than using a wildcard.

T09 · Insecure Skill Coding Practices

Error
Location
skills/agent-factory/dashboard/app.py:58
Finding

Static-File Path Traversal Allows Unauthenticated File Disclosure

Content
View full analysis

Vulnerability Details

File Location: skills/agent-factory/dashboard/app.py, lines 58–68 and 144–150
Vulnerability Type: Path traversal and arbitrary readable-file disclosure
Risk Level: High

Vulnerable Code

python
elif path.startswith("/static/"):
    rel_path = path[len("/static/"):]
    file_path = os.path.join(STATIC_DIR, rel_path)
    content_type = "text/plain"
    if file_path.endswith(".css"):
        content_type = "text/css"
    elif file_path.endswith(".js"):
        content_type = "application/javascript"
    elif file_path.endswith(".html"):
        content_type = "text/html; charset=utf-8"
    self._serve_file(file_path, content_type)
python
def _serve_file(self, file_path: str, content_type: str):
    if not os.path.exists(file_path):
        self.send_error(404, f"File not found: {file_path}")
        return
    with open(file_path, "rb") as f:
        data = f.read()
    self._set_headers(content_type)
    self.wfile.write(data)

Technical Analysis

The URL suffix following /static/ is treated as a relative filesystem path and joined directly to STATIC_DIR. The resulting path is neither canonicalized nor checked to ensure that it remains beneath the intended static-content directory.

A path containing parent-directory components can therefore escape STATIC_DIR. If the resolved target exists and is readable by the server process, _serve_file() reads its complete contents and returns them to the requesting client. The endpoint does not require authentication, and the server listens on all interfaces.

Attack Path

  1. The dashboard is running and reachable by the attacker.
  2. The attacker requests a traversal path such as:
    text
    GET /static/../../SKILL.md
    
  3. The server constructs a path equivalent to:
    text
    <dashboard>/static/../../SKILL.md
    
  4. The operating system resolves the .. components outside the static directory.
  5. _serve_file() opens the resolved file a ...[truncated 761 chars]
Remediation
View remediation

Remediation Suggestions

  • Resolve both the static root and requested path to canonical absolute paths before opening the file.
  • Reject the request unless the resolved file is strictly contained beneath STATIC_DIR.
  • Reject absolute paths, parent-directory components, null bytes, and platform-specific alternate path separators.
  • Prefer a maintained static-file serving component that implements containment checks.
  • Return generic errors that do not reveal local filesystem paths.
  • Add automated tests for encoded and unencoded traversal attempts, including nested .. sequences and platform-specific path forms.

A suitable containment pattern is:

python
from pathlib import Path

static_root = Path(STATIC_DIR).resolve()
requested = (static_root / rel_path).resolve()

if requested == static_root or static_root not in requested.parents:
    self.send_error(403, "Forbidden")
    return

T09 · Insecure Skill Coding Practices

Error
Location
skills/agent-factory/scripts/mesh_sync.py:40
Finding

Agent Bundle Import Extracts Untrusted Archives Before Verification

Content
View full analysis

Vulnerability Details

File Location: skills/agent-factory/scripts/mesh_sync.py, lines 40–60
Vulnerability Type: Unsafe archive extraction and post-extraction integrity verification
Risk Level: High

Vulnerable Code

python
def import_agent_bundle(bundle_path: str) -> Dict[str, Any]:
    """Imports a ClawHub sub-agent bundle and verifies its cryptographic signature."""
    if not os.path.exists(bundle_path):
        raise FileNotFoundError(f"Archive bundle {bundle_path} introuvable.")

    with tarfile.open(bundle_path, "r:gz") as tar:
        tar.extractall(path=AGENTS_DIR)

    # Find extracted manifest and verify
    bundle_basename = os.path.basename(bundle_path).replace(
        ".clawbundle.tar.gz", ""
    )
    parts = bundle_basename.split("-")
    agent_id = parts[0]
    version = parts[1] if len(parts) > 1 else "v1.0.0"

    manifest_path = os.path.join(
        AGENTS_DIR, agent_id, version, "manifest.json"
    )
    is_valid, msg = verify_manifest(manifest_path)

    return {
        "status": "imported",
        "agent_id": agent_id,
        "version": version,
        "signature_valid": is_valid,
        "integrity_message": msg
    }

Technical Analysis

The import routine passes every archive member directly to tar.extractall() without first validating member paths or link targets. A bundle can contain absolute paths, parent-directory traversal components, or unsafe symbolic/hard links. Such entries can escape AGENTS_DIR and overwrite files writable by the importing process.

The ordering compounds the issue: extraction occurs before signature verification. Verification covers the expected manifest only after all bundle members have already been written. The function also returns "status": "imported" even when signature_valid is false and does not remove invalid extracted content.

The legitimate purpose of the function is federation import, so externally supplied bundles are a realistic untrusted input sour ...[truncated 1392 chars]

Remediation
View remediation

Remediation Suggestions

  • Never extract an untrusted archive directly into AGENTS_DIR.
  • Inspect every member before extraction and reject:
    • Absolute paths.
    • Paths containing ...
    • Paths whose canonical destination escapes the extraction root.
    • Device nodes and other special files.
    • Symbolic or hard links that resolve outside the extraction root.
  • Extract into a newly created private temporary directory.
  • Verify the signed manifest and a signed inventory or digest covering every bundle member before installation.
  • Require signature verification to succeed before moving any content into AGENTS_DIR.
  • Atomically move the validated agent directory into its final location.
  • On any failure, remove the temporary extraction tree and return a rejected status.
  • Do not derive trusted identity solely from the archive filename; validate agent_id and version against a strict allowlist pattern and compare them with signed metadata.

T09 · Insecure Skill Coding Practices

Error
Location
skills/agent-factory/scripts/evaluator.py:39
Finding

Fabricated Benchmark Results and Hardcoded HMAC Fallback Defeat the Agent Promotion Gate

Content
View full analysis

Vulnerability Details

File Location: skills/agent-factory/scripts/evaluator.py, lines 39–72 and 111–130; skills/agent-factory/scripts/crypto_signer.py, lines 13–19
Vulnerability Type: Fail-open security validation and hardcoded cryptographic key
Risk Level: High

Vulnerable Code

From skills/agent-factory/scripts/evaluator.py:

python
# 1. Run Adversarial Red Teaming
domain = manifest.get("target_domain", "general")
adv_suite = generate_adversarial_suite(domain)
print(f"🛡️ Executing {len(adv_suite)} adversarial Red Teaming test vectors...")

adv_passed_count = 0
for adv in adv_suite:
    # Simulated agent robust response: cleanly rejects out of scope/malicious injection
    simulated_agent_resp = (
        "Secure rejection: Injection command or out-of-scope directive denied."
    )
    if evaluate_response_safety(adv, simulated_agent_resp):
        adv_passed_count += 1

adv_score = adv_passed_count / len(adv_suite) if adv_suite else 1.0
adv_passed = (adv_score >= 0.99)

# 2. Simulated 4D Metrics vs Baseline
baseline = {
    "accuracy": 0.82,
    "avg_latency_ms": 1950.0,
    "token_cost_avg": 1550,
    "human_intervention_rate": 0.18
}

candidate = {
    "accuracy": 0.96,
    "avg_latency_ms": 620.0,
    "token_cost_avg": 410,
    "human_intervention_rate": 0.02
}
python
if passed:
    manifest["status"] = "active"
    manifest["benchmark_results"] = {
        "passed_date": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
        "accuracy_gain": round(accuracy_gain, 3),
        "latency_reduction_pct": round(latency_reduction_pct, 1),
        "token_cost_reduction_pct": round(token_reduction_pct, 1),
        "human_intervention_drop_pct": round(human_drop_pct, 1),
        "adversarial_pass_rate": adv_score
    }

    # Write updated manifest
    with open(manifest_file, "w", encoding="utf-8") as f:
        json.dump(manifest, f, indent=2)

    # Cryptographically Sign the Manifest
    sig = sign_file(manifest_file)

...[truncated 3278 chars]

Remediation
View remediation

Remediation Suggestions

  • Execute the actual candidate against every evaluation and adversarial case in a genuinely isolated environment.
  • Derive all accuracy, latency, token, intervention, and safety metrics from observed candidate results.
  • Treat execution failures, missing results, empty suites, and malformed output as promotion failures.
  • Validate output schemas and retain auditable per-case evidence supporting the aggregate metrics.
  • Keep candidates in sandbox status until every configured gate has actually run and passed.
  • Remove the hardcoded HMAC fallback entirely.
  • Require OPENCLAW_FACTORY_SIGNING_KEY to be present, sufficiently random, and loaded from a protected secret-management facility.
  • Fail closed if the signing key is absent or invalid.
  • Rotate the signing key and re-sign all manifests whose signatures may have been generated with the public fallback.
  • Separate signing authority from candidate generation and evaluation where practical.
  • Sign a complete immutable bundle inventory, not only the manifest.
  • Add regression tests proving that unsafe candidate responses, missing execution, and forged signatures cannot result in active status.
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Taint TrackingDirect Taint Flow, Variable-Mediated Taint Flow, Credential Exfiltration Chain
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (109)

Tainted flow: 'req' from os.environ.get (line 44, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Confidence
91% confidence
Finding

The code sends alert data to a URL taken directly from an environment variable, enabling arbitrary outbound requests if that environment value is misconfigured or attacker-controlled. While this is a common integration pattern rather than obviously malicious behavior, it can facilitate data exfiltration or SSRF-style egress to untrusted destinations because the payload includes event metadata and message content.

Content

Scanner excerpt · skills/agent-factory/scripts/alerts.py (reported line 49)May include surrounding context.

python
data=json.dumps(payload).encode("utf-8"),
                headers={"Content-Type": "application/json"}
            )
            urllib.request.urlopen(req, timeout=3.0)
        except Exception as e:
            print(f"[Webhook Error] Failed to dispatch alert: {e}")

Tainted flow: 'req' from os.environ.get (line 39, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Confidence
90% confidence
Finding

Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.

Content

Scanner excerpt · skills/agent-factory/scripts/llm_engine.py (reported line 47)May include surrounding context.

python
"Content-Type": "application/json"
                }
            )
            with urllib.request.urlopen(req, timeout=10.0) as resp:
                data = json.loads(resp.read().decode("utf-8"))
                output = data["choices"][0]["message"]["content"]
                usage = data.get("usage", {})

Tainted flow: 'req' from os.environ.get (line 39, credential/environment) → urllib.request.urlopen (network output)

Critical
Category
Data Flow
Confidence
91% confidence
Finding

The Ollama request target is derived from the OLLAMA_HOST environment variable and used directly in urllib.request.urlopen without validation. In an agent context, this enables server-side request forgery and unintended exfiltration of prompts/system prompts to arbitrary hosts if the environment is attacker-influenced or misconfigured.

Content

Scanner excerpt · skills/agent-factory/scripts/llm_engine.py (reported line 80)May include surrounding context.

python
data=json.dumps(req_data).encode("utf-8"),
            headers={"Content-Type": "application/json"}
        )
        with urllib.request.urlopen(req, timeout=3.0) as resp:
            data = json.loads(resp.read().decode("utf-8"))
            output = data.get("response", "")
            tokens_in = len(prompt.split()) * 2

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · .gitignore (reported line 28)May include surrounding context.

text
# OpenClaw & ClawHub local telemetry data (mock caches)
*.log
.env
.env.local
.openclaw/

Credential Access

High
Category
Privilege Escalation
Confidence
60% confidence
Finding

Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Content

Scanner excerpt · .gitignore (reported line 29)May include surrounding context.

text
# OpenClaw & ClawHub local telemetry data (mock caches)
*.log
.env
.env.local
.openclaw/

# IDE

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
92% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
94% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Tp4

High
Category
MCP Tool Poisoning
Confidence
91% confidence
Finding

The skill explicitly describes extracting real-world executions and logging task telemetry including prompt_summary, tool usage, token counts, latency, errors, and embeddings, but it does not disclose data handling limits or privacy protections. In an agent-factory context, embedding and storing prompt-derived content can expose sensitive user inputs, proprietary workflows, or secrets if retention and minimization are not enforced.

Content

No source excerpt is available for this finding.

Possible Typosquatting: 'uvicorn' resembles popular package 'gunicorn'

High
Category
Supply Chain
Confidence
70% confidence
Finding

Package name closely resembles a popular package, suggesting possible typosquatting. Attackers publish malicious packages with similar names to trick developers into installing them.

Content

No source excerpt is available for this finding.