Merge commit from fork

Signed-off-by: degenaro <lou.degenaro@gmail.com>

Author: degenaro

tests/trestle/core/remote/cache_security_test.py

@@ -102,6 +102,265 @@ def mock_relative_to(self, other, *args, **kwargs):
             PathSecurityValidator.validate_cache_path(valid_path, cache_root)
 
 
+class TestTrestleURIPathValidation:
+    """Test trestle:// URI path validation."""
+
+    def test_validate_trestle_uri_path_normal(self) -> None:
+        """Test that normal trestle:// URI paths pass validation."""
+        PathSecurityValidator.validate_trestle_uri_path('catalogs/nist/catalog.json')
+        PathSecurityValidator.validate_trestle_uri_path('profiles/fedramp/profile.json')
+        PathSecurityValidator.validate_trestle_uri_path('components/mycomp/component.json')
+
+    def test_validate_trestle_uri_path_blocks_traversal(self) -> None:
+        """Test that trestle:// URI paths with .. are blocked."""
+        with pytest.raises(TrestleError, match='Security violation:.*[Pp]ath traversal blocked.*trestle://'):
+            PathSecurityValidator.validate_trestle_uri_path('../../etc/passwd')
+
+        with pytest.raises(TrestleError, match='Security violation:.*[Pp]ath traversal blocked.*trestle://'):
+            PathSecurityValidator.validate_trestle_uri_path('catalogs/../../../etc/shadow')
+
+        with pytest.raises(TrestleError, match='Security violation:.*[Pp]ath traversal blocked.*trestle://'):
+            PathSecurityValidator.validate_trestle_uri_path('../sensitive/file.json')
+
+
+class TestLocalPathValidation:
+    """Test local path validation."""
+
+    def test_validate_local_path_within_workspace(self, tmp_path: pathlib.Path) -> None:
+        """Test that valid paths within trestle workspace are accepted."""
+        trestle_root = tmp_path / 'trestle-workspace'
+        trestle_root.mkdir(parents=True)
+
+        # Valid path within workspace
+        valid_path = trestle_root / 'catalogs' / 'nist' / 'catalog.json'
+        PathSecurityValidator.validate_local_path(valid_path, trestle_root)  # Should not raise
+
+    def test_validate_local_path_traversal_blocked(self, tmp_path: pathlib.Path) -> None:
+        """Test that path traversal outside workspace is blocked."""
+        trestle_root = tmp_path / 'trestle-workspace'
+        trestle_root.mkdir(parents=True)
+
+        # Attempt to traverse outside workspace
+        evil_path = trestle_root / '..' / '..' / 'etc' / 'passwd'
+
+        with pytest.raises(TrestleError, match='Security violation.*[Pp]ath traversal blocked'):
+            PathSecurityValidator.validate_local_path(evil_path, trestle_root)
+
+    def test_validate_local_path_absolute_outside_blocked(self, tmp_path: pathlib.Path) -> None:
+        """Test that absolute paths outside workspace are blocked."""
+        trestle_root = tmp_path / 'trestle-workspace'
+        trestle_root.mkdir(parents=True)
+
+        # Absolute path outside workspace
+        evil_path = pathlib.Path('/tmp/pwned.json')
+
+        with pytest.raises(TrestleError, match='Security violation.*[Pp]ath traversal blocked'):
+            PathSecurityValidator.validate_local_path(evil_path, trestle_root)
+
+    def test_validate_local_path_unexpected_error(self, tmp_path: pathlib.Path, monkeypatch) -> None:
+        """Test that unexpected errors during validation are caught and wrapped."""
+        trestle_root = tmp_path / 'trestle-workspace'
+        trestle_root.mkdir(parents=True)
+
+        valid_path = trestle_root / 'catalogs' / 'file.json'
+
+        # Mock relative_to() to raise an unexpected exception (not ValueError)
+        def mock_relative_to(self, other, *args, **kwargs):
+            raise RuntimeError('Unexpected filesystem error')
+
+        monkeypatch.setattr(pathlib.Path, 'relative_to', mock_relative_to)
+
+        with pytest.raises(TrestleError, match='Error validating local path'):
+            PathSecurityValidator.validate_local_path(valid_path, trestle_root)
+
+
+class TestLocalFilePathValidation:
+    """Test local file path validation with workspace boundaries and sensitive file checks."""
+
+    def test_validate_local_file_path_within_workspace(self, tmp_path: pathlib.Path) -> None:
+        """Test that files within workspace are allowed."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        file_path = workspace / 'catalogs' / 'catalog.json'
+        PathSecurityValidator.validate_local_file_path(workspace, file_path, allow_outside_workspace=False)
+
+    def test_validate_local_file_path_outside_workspace_blocked(self, tmp_path: pathlib.Path) -> None:
+        """Test that files outside workspace are blocked when allow_outside_workspace=False."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        outside_file = tmp_path / 'outside.json'
+
+        with pytest.raises(TrestleError, match='Access to files outside the trestle workspace is not allowed'):
+            PathSecurityValidator.validate_local_file_path(workspace, outside_file, allow_outside_workspace=False)
+
+    def test_validate_local_file_path_outside_workspace_allowed(self, tmp_path: pathlib.Path) -> None:
+        """Test that non-sensitive files outside workspace are allowed when allow_outside_workspace=True."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        # Create a safe file outside workspace
+        outside_file = tmp_path / 'safe_file.json'
+        outside_file.touch()
+
+        # Should not raise
+        PathSecurityValidator.validate_local_file_path(workspace, outside_file, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_etc_passwd(self, tmp_path: pathlib.Path) -> None:
+        """Test that /etc/passwd is blocked even with allow_outside_workspace=True."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        passwd_path = pathlib.Path('/etc/passwd')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, passwd_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_etc_shadow(self, tmp_path: pathlib.Path) -> None:
+        """Test that /etc/shadow is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        shadow_path = pathlib.Path('/etc/shadow')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, shadow_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_etc_group(self, tmp_path: pathlib.Path) -> None:
+        """Test that /etc/group is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        group_path = pathlib.Path('/etc/group')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, group_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_etc_sudoers(self, tmp_path: pathlib.Path) -> None:
+        """Test that /etc/sudoers is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        sudoers_path = pathlib.Path('/etc/sudoers')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, sudoers_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_ssh_directory(self, tmp_path: pathlib.Path) -> None:
+        """Test that .ssh directory is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        ssh_path = pathlib.Path('/home/user/.ssh/id_rsa')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, ssh_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_aws_credentials(self, tmp_path: pathlib.Path) -> None:
+        """Test that .aws credentials are blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        aws_path = pathlib.Path('/home/user/.aws/credentials')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, aws_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_docker_config(self, tmp_path: pathlib.Path) -> None:
+        """Test that .docker config is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        docker_path = pathlib.Path('/home/user/.docker/config.json')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, docker_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_kube_config(self, tmp_path: pathlib.Path) -> None:
+        """Test that .kube config is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        kube_path = pathlib.Path('/home/user/.kube/config')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, kube_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_proc_environ(self, tmp_path: pathlib.Path) -> None:
+        """Test that /proc/self/environ is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        proc_path = pathlib.Path('/proc/self/environ')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, proc_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_windows_system32(self, tmp_path: pathlib.Path) -> None:
+        """Test that Windows System32 is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        win_path = pathlib.Path('C:\\Windows\\System32\\config\\SAM')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, win_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_windows_credentials(self, tmp_path: pathlib.Path) -> None:
+        """Test that Windows credentials are blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        cred_path = pathlib.Path('C:\\Users\\user\\AppData\\Local\\Microsoft\\Credentials\\secret')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, cred_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_var_log(self, tmp_path: pathlib.Path) -> None:
+        """Test that /var/log is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        log_path = pathlib.Path('/var/log/auth.log')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, log_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_blocks_mysql_data(self, tmp_path: pathlib.Path) -> None:
+        """Test that MySQL data directory is blocked."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        mysql_path = pathlib.Path('/var/lib/mysql/users.MYD')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, mysql_path, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_case_insensitive(self, tmp_path: pathlib.Path) -> None:
+        """Test that sensitive path checking is case-insensitive."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        # Test uppercase variations
+        passwd_upper = pathlib.Path('/ETC/PASSWD')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, passwd_upper, allow_outside_workspace=True)
+
+    def test_validate_local_file_path_checks_original_and_resolved(self, tmp_path: pathlib.Path) -> None:
+        """Test that both original and resolved paths are checked for sensitive patterns."""
+        workspace = tmp_path / 'workspace'
+        workspace.mkdir(parents=True)
+
+        # Create a path that might resolve differently
+        # The validator checks both the original string and resolved path
+        sensitive_path = pathlib.Path('/home/user/.ssh/authorized_keys')
+
+        with pytest.raises(TrestleError, match='Attempt to access potentially sensitive system file'):
+            PathSecurityValidator.validate_local_file_path(workspace, sensitive_path, allow_outside_workspace=True)
+
+
 class TestHTTPSFetcherPathTraversal:
     """Test HTTPSFetcher protection against path traversal attacks."""
 

trestle/core/remote/cache.py

@@ -166,16 +166,29 @@ def __init__(self, trestle_root: pathlib.Path, uri: str) -> None:
         """
         super().__init__(trestle_root, uri)
 
+        original_uri = uri
+        is_file_uri = uri.startswith(const.FILE_URI)
+
         # Handle as file:/// form
-        if uri.startswith(const.FILE_URI):
+        if is_file_uri:
             # strip off entire header including /
             uri = uri[len(const.FILE_URI) :]
 
             # if it has a drive letter don't add / to front
             uri = uri if re.match(const.WINDOWS_DRIVE_LETTER_REGEX, uri) else '/' + uri
         elif uri.startswith(const.TRESTLE_HREF_HEADING):
-            uri = str(trestle_root / uri[len(const.TRESTLE_HREF_HEADING) :])
+            # Extract the path after 'trestle://'
+            trestle_path = uri[len(const.TRESTLE_HREF_HEADING) :]
+
+            # Layer 1: Validate the trestle:// URI path for traversal sequences
+            PathSecurityValidator.validate_trestle_uri_path(trestle_path)
+
+            uri = str(trestle_root / trestle_path)
             self._abs_path = pathlib.Path(uri).resolve()
+
+            # Layer 2: Validate resolved path stays within trestle workspace
+            PathSecurityValidator.validate_local_path(self._abs_path, self._trestle_root)
+
             self._cached_object_path = self._abs_path
             return
 
@@ -196,6 +209,13 @@ def __init__(self, trestle_root: pathlib.Path, uri: str) -> None:
         except Exception:
             raise TrestleError(f'The uri provided is invalid or unresolvable as a file path: {uri}')
 
+        # Security validation for file:// URIs and relative paths
+        # LocalFetcher is designed to access files outside workspace (e.g., test data, external catalogs)
+        # Security is provided by blocking sensitive system files, not workspace boundaries
+        # This prevents arbitrary file read vulnerabilities (PT-002) while allowing legitimate use
+        logger.info(f'Validating local file access: {original_uri}')
+        PathSecurityValidator.validate_local_file_path(self._trestle_root, self._abs_path, allow_outside_workspace=True)
+
         # set the cached path to be the actual file path
         self._cached_object_path = self._abs_path