fix: guard search_tool's root and trim the NT-namespace tests to two invariants

search_tool resolved its root via _resolve_path_for_task BEFORE the
NT-namespace check saw it (review finding): on Windows the resolve is the
SMB-auth trigger, on POSIX the task-base join hides the prefix from the
resolved-path denylist. The raw-string guard now runs first there too,
and the guard rides the existing top-level agent.file_safety import
instead of two function-local imports.

The tool-layer chokepoint test now covers all four entries and proves
none of them touched Path/_resolve_path_for_task/realpath before the
refusal; the 12 form-matrix tests collapse into one blocked/allowed
invariant over both classifiers.
This commit is contained in:
teknium1
2026-09-14 18:49:49 -07:00
committed by Teknium
parent faf71eb4c1
commit 07e6461dfe
+47 -117
View File
@@ -1,149 +1,79 @@
"""Tests for the Windows NT-namespace path guard in agent.file_safety.
"""Windows NT/device-namespace paths are rejected on the RAW string, before any resolution.
Inspired by Claude Code v2.1.234 (Aug 2026): file accesses reject Windows
NT-namespace (``\\??\\``) paths to harden against the NTLM credential-leak
vector — merely resolving ``\\??\\UNC\\host\\share`` triggers outbound SMB
authentication on Windows, and NT-namespace prefixes bypass the Win32 path
normalization that prefix-based denylists rely on.
The guard must fire on the RAW string before any ``resolve()``/``realpath()``
call, on every platform (path strings can be relayed toward Windows hosts by
remote terminal backends and desktop bridges).
On Windows, merely resolving ``\\??\\UNC\\host\\share`` (or the ``\\\\?\\UNC\\`` /
``GLOBALROOT`` re-entry forms) initiates SMB authentication and leaks the user's
NTLM hash, and the prefixes bypass the Win32 normalization that prefix denylists
rely on. So the guard must fire on the model-supplied string before
``resolve()``/``realpath()``/the task-base join, on every platform.
"""
import os
import unittest
from unittest.mock import patch
from agent.file_safety import (
get_nt_namespace_error,
get_read_block_error,
get_write_denied_error,
is_nt_namespace_path,
is_write_denied,
)
BLOCKED_PATHS = [
# NT object namespace — the canonical NTLM-leak form.
"\\??\\UNC\\attacker.example\\share\\x",
"\\??\\UNC\\attacker.example\\share\\x", # NT object namespace — the canonical leak form
"\\??\\C:\\Windows\\System32\\config\\SAM",
# Forward-slash spellings normalize to the same namespace on Windows.
"/??/UNC/attacker.example/share/x",
# Win32 device namespace.
"\\\\.\\PhysicalDrive0",
"/??/UNC/attacker.example/share/x", # forward-slash spelling
"\\\\.\\PhysicalDrive0", # Win32 device namespace
"\\\\.\\pipe\\evil",
"//./pipe/evil",
# Extended-length UNC (remote host) and NT-namespace re-entry.
"\\\\?\\UNC\\attacker.example\\share\\x",
"\\\\?\\unc\\attacker.example\\share\\x", # case-insensitive
"\\\\?\\GLOBALROOT\\Device\\HarddiskVolume1\\x",
"\\\\?\\UNC\\attacker.example\\share\\x", # extended-length UNC (remote host)
"\\\\?\\unc\\attacker.example\\share\\x", # case-insensitive
"\\\\?\\GLOBALROOT\\Device\\HarddiskVolume1\\x", # NT-namespace re-entry
"//?/UNC/attacker.example/share/x",
]
ALLOWED_PATHS = [
# Ordinary paths on both platforms.
"/tmp/test.py",
"/home/user/notes.txt",
"C:\\Users\\me\\notes.txt",
"C:/Users/me/notes.txt",
"~/projects/readme.md",
"relative/path.txt",
# Extended-length local drive paths are routine and carry no remote-auth
# trigger (see hermes_cli/windows_ssh_runtime.py).
"\\\\?\\C:\\Users\\me\\notes.txt",
# Plain UNC shares are a separate policy question — NOT blocked by this
# namespace guard.
"\\\\server\\share\\file.txt",
"\\\\?\\C:\\Users\\me\\notes.txt", # extended-length LOCAL drive: routine, no remote-auth trigger
"\\\\server\\share\\file.txt", # plain UNC share: separate policy question, not this guard
"//server/share/file.txt",
# A '??' mid-path is data, not a namespace marker.
"/tmp/??/weird-dir/file",
"/tmp/??/weird-dir/file", # '??' mid-path is data, not a namespace marker
]
class TestIsNtNamespacePath(unittest.TestCase):
def test_blocked_forms(self):
for path in BLOCKED_PATHS:
self.assertTrue(is_nt_namespace_path(path), f"{path!r} should be detected")
class TestNtNamespaceGuard(unittest.TestCase):
def test_predicate_and_both_chokepoint_classifiers(self):
for p in BLOCKED_PATHS:
self.assertTrue(is_nt_namespace_path(p), p)
self.assertIn("NT/device namespace", get_read_block_error(p) or "", p)
self.assertIn("Write denied", get_write_denied_error(p) or "", p)
for p in ALLOWED_PATHS:
self.assertFalse(is_nt_namespace_path(p), p)
self.assertNotIn("NT/device namespace", get_read_block_error(p) or "", p)
self.assertNotIn("NT/device namespace", get_write_denied_error(p) or "", p)
def test_allowed_forms(self):
for path in ALLOWED_PATHS:
self.assertFalse(is_nt_namespace_path(path), f"{path!r} should NOT be detected")
def test_file_tools_reject_raw_string_without_resolving(self):
"""Every file-tool entry refuses BEFORE the task-base join / resolve — the
resolve is the leak, and on POSIX the join would hide the prefix."""
from tools.file_tools import patch_tool, read_file_tool, search_tool, write_file_tool
class TestReadGuard(unittest.TestCase):
def test_read_blocked_with_actionable_message(self):
for path in BLOCKED_PATHS:
err = get_read_block_error(path)
self.assertIsNotNone(err, f"{path!r} should be read-blocked")
self.assertIn("Read denied", err)
self.assertIn("NT/device namespace", err)
def test_legitimate_reads_unaffected(self):
for path in ("/tmp/test.py", "\\\\?\\C:\\Users\\me\\notes.txt"):
err = get_read_block_error(path)
if err is not None:
# Must not be blocked by THIS guard (other denylist rules
# could theoretically match in exotic environments).
self.assertNotIn("NT/device namespace", err)
def test_guard_does_not_resolve_the_path(self):
"""The check must run on the raw string — resolving is the leak."""
from unittest.mock import patch
with patch("agent.file_safety.Path") as mock_path:
err = get_read_block_error("\\??\\UNC\\attacker.example\\share\\x")
self.assertIsNotNone(err)
mock_path.assert_not_called()
class TestWriteGuard(unittest.TestCase):
def test_write_blocked(self):
for path in BLOCKED_PATHS:
self.assertTrue(is_write_denied(path), f"{path!r} should be write-denied")
err = get_write_denied_error(path)
self.assertIsNotNone(err)
self.assertIn("NT/device namespace", err)
self.assertIn("Write denied", err)
def test_legitimate_writes_unaffected(self):
self.assertFalse(is_write_denied("/tmp/scratch/output.txt"))
self.assertFalse(is_write_denied("\\\\?\\C:\\Users\\me\\notes.txt"))
class TestErrorHelper(unittest.TestCase):
def test_none_for_normal_paths(self):
self.assertIsNone(get_nt_namespace_error("/tmp/x"))
def test_verb_customization(self):
err = get_nt_namespace_error("\\??\\UNC\\h\\s\\f", verb="Read")
assert err is not None
self.assertTrue(err.startswith("Read denied"))
class TestToolLayerChokepoints(unittest.TestCase):
"""The raw string must be rejected at the tool entry points, before the
task-base join anchors ``\\??\\...`` under a POSIX base dir and hides the
prefix from resolved-path checks."""
BAD = "\\??\\UNC\\attacker.example\\share\\x"
def test_read_file_tool_rejects_raw(self):
from tools.file_tools import read_file_tool
result = read_file_tool(self.BAD)
self.assertIn("NT/device namespace", result)
def test_write_file_tool_rejects_raw(self):
from tools.file_tools import write_file_tool
result = write_file_tool(self.BAD, "data")
self.assertIn("NT/device namespace", str(result))
def test_patch_tool_rejects_raw(self):
from tools.file_tools import patch_tool
result = patch_tool(mode="replace", path=self.BAD,
old_string="a", new_string="b")
self.assertIn("NT/device namespace", str(result))
bad = "\\??\\UNC\\attacker.example\\share\\x"
with patch("agent.file_safety.Path") as fs_path, \
patch("tools.file_tools._resolve_path_for_task") as ft_resolve, \
patch("tools.file_tools_write_guards._resolve_path_for_task") as wg_resolve, \
patch.object(os.path, "realpath", side_effect=AssertionError("must not realpath")):
results = [
read_file_tool(bad),
write_file_tool(bad, "data"),
patch_tool(mode="replace", path=bad, old_string="a", new_string="b"),
search_tool("x", path=bad),
]
fs_path.assert_not_called()
ft_resolve.assert_not_called()
wg_resolve.assert_not_called()
for r in results:
self.assertIn("NT/device namespace", r)
if __name__ == "__main__":