fix(extensions): enforce trusted catalog identity boundaries

Catalog entries can originate from remote/community sources and cached state, so install and info resolution must not coerce malformed fields into usable names or IDs. This keeps display-name lookup aligned with rendering, requires whole-string ID validation, and prevents default download cache writes through symlinked project paths.

Author: darion-yaphet

src/specify_cli/extensions/__init__.py

@@ -239,7 +239,7 @@ def _validate(self):
                 raise ValidationError(f"Missing extension.{field}")
 
         # Validate extension ID format
-        if not EXTENSION_ID_PATTERN.match(ext["id"]):
+        if not EXTENSION_ID_PATTERN.fullmatch(ext["id"]):
             raise ValidationError(
                 f"Invalid extension ID '{ext['id']}': "
                 "must be lowercase alphanumeric with hyphens only"
@@ -2050,6 +2050,54 @@ def __init__(self, project_root: Path):
         self.cache_file = self.cache_dir / "catalog.json"
         self.cache_metadata_file = self.cache_dir / "catalog-metadata.json"
 
+    def _ensure_default_download_cache_dir(self) -> Path:
+        """Create the default download cache without following symlink parents."""
+        root = self.project_root.resolve()
+        target_dir = self.cache_dir / "downloads"
+        try:
+            rel = target_dir.relative_to(self.project_root)
+        except ValueError:
+            raise ExtensionError("Default extension download cache escapes project root") from None
+
+        current = self.project_root
+        for part in rel.parts:
+            current = current / part
+            try:
+                label = current.relative_to(self.project_root).as_posix()
+            except ValueError:
+                label = str(current)
+
+            if current.is_symlink():
+                raise ExtensionError(
+                    f"Refusing to use symlinked extension download cache path: {label}"
+                )
+            if current.exists():
+                if not current.is_dir():
+                    raise ExtensionError(
+                        f"Extension download cache path is not a directory: {label}"
+                    )
+                try:
+                    current.resolve().relative_to(root)
+                except (OSError, ValueError):
+                    raise ExtensionError(
+                        f"Extension download cache path escapes project root: {label}"
+                    ) from None
+                continue
+
+            current.mkdir()
+            if current.is_symlink():
+                raise ExtensionError(
+                    f"Refusing to use symlinked extension download cache path: {label}"
+                )
+            try:
+                current.resolve().relative_to(root)
+            except (OSError, ValueError):
+                raise ExtensionError(
+                    f"Extension download cache path escapes project root: {label}"
+                ) from None
+
+        return target_dir
+
     def _make_request(self, url: str):
         """Build a urllib Request, adding auth headers when a provider matches.
 
@@ -2611,7 +2659,7 @@ def download_extension(
         """
         import urllib.error
 
-        if not isinstance(extension_id, str) or not EXTENSION_ID_PATTERN.match(
+        if not isinstance(extension_id, str) or not EXTENSION_ID_PATTERN.fullmatch(
             extension_id
         ):
             raise ExtensionError(
@@ -2648,8 +2696,9 @@ def download_extension(
 
         # Determine target path
         if target_dir is None:
-            target_dir = self.cache_dir / "downloads"
-        target_dir.mkdir(parents=True, exist_ok=True)
+            target_dir = self._ensure_default_download_cache_dir()
+        else:
+            target_dir.mkdir(parents=True, exist_ok=True)
 
         version = _safe_version_token(ext_info.get("version"))
         zip_filename = f"{extension_id}-{version}.zip"

src/specify_cli/extensions/_commands.py

@@ -204,7 +204,11 @@ def _resolve_catalog_extension(
 
         # Try by display name - search using argument as query, then filter for exact match
         search_results = catalog.search(query=argument)
-        name_matches = [ext for ext in search_results if str(ext.get("name", "")).lower() == argument.lower()]
+        name_matches = [
+            ext
+            for ext in search_results
+            if _catalog_id(ext) and _catalog_str(ext, "name").lower() == argument.lower()
+        ]
 
         if len(name_matches) == 1:
             return (name_matches[0], None)
@@ -221,10 +225,10 @@ def _resolve_catalog_extension(
             table.add_column("Catalog", style="dim")
             for ext in name_matches:
                 table.add_row(
-                    _escape_markup(str(ext.get("id", ""))),
-                    _escape_markup(str(ext.get("name", ""))),
-                    _escape_markup(str(ext.get("version", ""))),
-                    _escape_markup(str(ext.get("_catalog_name", ""))),
+                    _escape_markup(_catalog_id(ext)),
+                    _escape_markup(_catalog_str(ext, "name", "(unnamed)")),
+                    _escape_markup(_catalog_str(ext, "version", "?")),
+                    _escape_markup(_catalog_str(ext, "_catalog_name")),
                 )
             console.print(table)
             console.print("\nPlease rerun using the extension ID:")

tests/test_extension_catalog_robustness.py

@@ -393,6 +393,58 @@ def fail_open_url(*args, **kwargs):
         catalog.download_extension(malicious_id)
 
 
+@pytest.mark.parametrize(
+    ("argument", "catalog_entry"),
+    [
+        (
+            "none",
+            {
+                "id": "null-name",
+                "name": None,
+                "version": "1.0.0",
+                "description": "JSON null name",
+            },
+        ),
+        (
+            "123",
+            {
+                "id": "numeric-name",
+                "name": 123,
+                "version": "1.0.0",
+                "description": "Numeric name",
+            },
+        ),
+        (
+            "Hidden Name",
+            {
+                "id": "../bad",
+                "name": "Hidden Name",
+                "version": "1.0.0",
+                "description": "Invalid ID",
+            },
+        ),
+    ],
+)
+def test_info_display_name_resolution_ignores_malformed_catalog_entries(
+    project_dir, monkeypatch, argument, catalog_entry
+):
+    """Display-name lookup must follow the same untrusted-entry rules as rendering.
+
+    JSON null / numeric names are unnamed, and invalid IDs are not installable
+    or addressable even when their display name matches exactly.
+    """
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(ExtensionCatalog, "get_extension_info", lambda self, ext_id: None)
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self, **kwargs: [catalog_entry])
+
+    result = runner.invoke(app, ["extension", "info", argument], obj={"project_root": project_dir})
+
+    assert result.exit_code == 1, result.output
+    assert f"Extension '{argument}' not found" in result.output
+
+
 def test_info_json_null_fields_render_placeholders_not_none(project_dir, monkeypatch):
     """`extension info` must coalesce JSON null fields, not print "None".
 

tests/test_extensions.py

@@ -362,6 +362,21 @@ def test_invalid_extension_id(self, temp_dir, valid_manifest_data):
         with pytest.raises(ValidationError, match="Invalid extension ID"):
             ExtensionManifest(manifest_path)
 
+    def test_extension_id_with_trailing_newline_is_invalid(self, temp_dir, valid_manifest_data):
+        """A trailing newline must not pass the extension ID regex anchor."""
+        import yaml
+
+        valid_manifest_data["extension"]["id"] = "valid-id\n"
+        valid_manifest_data["provides"]["commands"] = []
+        valid_manifest_data["hooks"] = {}
+
+        manifest_path = temp_dir / "extension.yml"
+        with open(manifest_path, "w") as f:
+            yaml.dump(valid_manifest_data, f)
+
+        with pytest.raises(ValidationError, match="Invalid extension ID"):
+            ExtensionManifest(manifest_path)
+
     def test_invalid_version(self, temp_dir, valid_manifest_data):
         """Test manifest with invalid semantic version."""
         import yaml
@@ -5878,6 +5893,55 @@ def test_download_extension_raises_no_url_for_non_bundled(self, temp_dir):
             with pytest.raises(ExtensionError, match="has no download URL"):
                 catalog.download_extension("some-ext")
 
+    def test_download_extension_rejects_trailing_newline_id(self, temp_dir):
+        """download_extension must require the whole extension ID to match."""
+        project_dir = temp_dir / "project"
+        project_dir.mkdir()
+        (project_dir / ".specify").mkdir()
+
+        catalog = ExtensionCatalog(project_dir)
+
+        with pytest.raises(ExtensionError, match="Invalid extension ID"):
+            catalog.download_extension("valid-id\n")
+
+    def test_download_extension_rejects_symlinked_default_cache(self, temp_dir):
+        """The default download cache must not follow symlinked project paths."""
+        from unittest.mock import patch
+
+        if not can_create_symlink(temp_dir):
+            pytest.skip("symlinks are not available in this environment")
+
+        project_dir = temp_dir / "project"
+        project_dir.mkdir()
+        extensions_dir = project_dir / ".specify" / "extensions"
+        extensions_dir.mkdir(parents=True)
+        outside_cache = temp_dir / "outside-cache"
+        outside_cache.mkdir()
+
+        try:
+            os.symlink(outside_cache, extensions_dir / ".cache")
+        except OSError:
+            pytest.skip("directory symlinks are not available in this environment")
+
+        catalog = ExtensionCatalog(project_dir)
+        ext_info = {
+            "name": "Test Extension",
+            "id": "test-ext",
+            "version": "1.0.0",
+            "description": "Test",
+            "download_url": "https://example.com/test-ext.zip",
+        }
+
+        def fail_open_url(*args, **kwargs):
+            raise AssertionError("download should not be attempted with symlinked cache")
+
+        with patch.object(catalog, "get_extension_info", return_value=ext_info), \
+             patch.object(catalog, "_open_url", side_effect=fail_open_url):
+            with pytest.raises(ExtensionError, match="symlinked extension download cache"):
+                catalog.download_extension("test-ext")
+
+        assert not (outside_cache / "downloads" / "test-ext-1.0.0.zip").exists()
+
 
 class TestExtensionUpdateCLI:
     """CLI integration tests for extension update command."""