forge-autonomy 2.7.36__tar.gz → 2.7.37__tar.gz

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.36
+Version: 2.7.37
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/forge/installed_lifecycle.py

@@ -498,6 +498,13 @@ def _exclusive_locks(paths: tuple[Path, ...]) -> Iterator[None]:
 
 
 def _assert_tree_has_no_links(root: Path) -> str:
+    """Prove one mutable instance tree is exclusively product-owned and safe."""
+    _assert_no_symlink_components(root)
+    root_info = root.lstat()
+    if not stat.S_ISDIR(root_info.st_mode):
+        raise InstalledLifecycleError("instance root is not a directory")
+    if stat.S_IMODE(root_info.st_mode) & 0o022:
+        raise InstalledLifecycleError("instance root is group/world writable")
     entries: list[dict[str, object]] = []
     for directory, names, files in os.walk(root, topdown=True, followlinks=False):
         parent = Path(directory)
@@ -508,8 +515,14 @@ def _assert_tree_has_no_links(root: Path) -> str:
                 raise InstalledLifecycleError(f"instance tree contains an unsafe symbolic link: {path}")
             if not (stat.S_ISDIR(info.st_mode) or stat.S_ISREG(info.st_mode)):
                 raise InstalledLifecycleError(f"instance tree contains an unsupported filesystem entry: {path}")
+            if stat.S_IMODE(info.st_mode) & 0o022:
+                raise InstalledLifecycleError(f"instance tree contains a group/world writable entry: {path}")
+            if stat.S_ISREG(info.st_mode) and info.st_nlink != 1:
+                raise InstalledLifecycleError(f"instance tree contains a non-exclusive hardlinked file: {path}")
             entries.append({
                 "path": str(path.relative_to(root)), "mode": stat.S_IFMT(info.st_mode),
+                "permissions": stat.S_IMODE(info.st_mode),
+                "links": info.st_nlink if stat.S_ISREG(info.st_mode) else None,
                 "size": info.st_size if stat.S_ISREG(info.st_mode) else None,
             })
     return _digest_bytes(_json_bytes(entries))

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/forge/preserved_lifecycle.py

@@ -22,6 +22,7 @@ from .installed_lifecycle import (
     _assert_identity,
     _assert_no_symlink_components,
     _assert_quiescent,
+    _assert_tree_has_no_links,
     _atomic_json,
     _digest_bytes,
     _exclusive_locks,
@@ -41,8 +42,8 @@ PROVIDER_AUTH_PRESERVED = "PRESERVED_REQUIRES_REVERIFICATION"
 
 
 def _content_tree_digest(root: Path) -> str:
-    """Bind every regular byte in one exact, link-free instance tree."""
-    _assert_no_symlink_components(root)
+    """Bind every regular byte after shared exclusive-ownership admission."""
+    _assert_tree_has_no_links(root)
     entries: list[dict[str, object]] = []
     for directory, names, files in os.walk(root, topdown=True, followlinks=False):
         parent = Path(directory)

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/forge/qualification/server_runtime.py

@@ -22,6 +22,7 @@ from urllib.request import Request, urlopen
 from forge._version import canonical_version
 from forge.ep_simulator import EpSimulatorServer, EpSimulatorState
 from forge.installed_lifecycle import (
+    InstalledLifecycleError,
     InstalledUninstallDispatcher,
     UninstallRequest,
     UpdateAssessmentRequest,
@@ -249,6 +250,7 @@ def run(*, candidate_wheel: Path | None = None, source_revision: str | None = No
             "preserve": "NOT_REQUESTED",
             "restore": "NOT_REQUESTED",
             "purge": "NOT_REQUESTED",
+            "filesystem_security": "NOT_REQUESTED",
         }
         if candidate_wheel is not None:
             if source_revision is None or len(source_revision) != 40:
@@ -265,6 +267,50 @@ def run(*, candidate_wheel: Path | None = None, source_revision: str | None = No
                 raise RuntimeError("installed lifecycle update assessment did not bind the exact artifact")
             lifecycle["update_assessment"] = "PASS"
 
+            def unsafe_lifecycle_request(data_root: Path, operation_id: str) -> InstanceLifecycleRequest:
+                database = RuntimeBootstrap(data_root=data_root, forge_version=version).open()
+                try:
+                    runtime_id = database.runtime_identity.runtime_id
+                    installation_id = database.metadata["installation_id"]
+                finally:
+                    database.close()
+                return InstanceLifecycleRequest(
+                    operation_id=operation_id,
+                    instance_id=runtime_id,
+                    runtime_id=runtime_id,
+                    installation_id=installation_id,
+                    installed_version=version,
+                    installed_source=source_revision,
+                    installed_artifact_digest=wheel_digest,
+                    data_root=str(data_root),
+                    instances_root=str(root.resolve()),
+                )
+
+            hardlink_root = root / "unsafe-hardlink-instance"
+            hardlink_request = unsafe_lifecycle_request(hardlink_root, "installed-hardlink-negative")
+            foreign = root / "foreign-hardlink-source"
+            foreign.write_text("foreign", encoding="utf-8")
+            (hardlink_root / "unsafe-hardlink").hardlink_to(foreign)
+            try:
+                InstalledPreserveDispatcher(hardlink_request).run()
+            except InstalledLifecycleError as error:
+                if "hardlinked" not in str(error):
+                    raise RuntimeError("installed lifecycle rejected hardlink for an unexpected reason") from error
+            else:
+                raise RuntimeError("installed lifecycle accepted a foreign hardlink")
+
+            permissive_root = root / "unsafe-permissive-instance"
+            permissive_request = unsafe_lifecycle_request(permissive_root, "installed-permissive-negative")
+            permissive_root.chmod(0o777)
+            try:
+                InstalledPreserveDispatcher(permissive_request).run()
+            except InstalledLifecycleError as error:
+                if "group/world writable" not in str(error):
+                    raise RuntimeError("installed lifecycle rejected permissive root for an unexpected reason") from error
+            else:
+                raise RuntimeError("installed lifecycle accepted a group/world writable root")
+            lifecycle["filesystem_security"] = "PASS"
+
             preserve_request = InstanceLifecycleRequest(
                 operation_id="forge-server-runtime-installed-preserve",
                 instance_id=identities[0],
@@ -399,6 +445,7 @@ def run(*, candidate_wheel: Path | None = None, source_revision: str | None = No
             "lifecycle_preserve": lifecycle["preserve"],
             "lifecycle_restore": lifecycle["restore"],
             "lifecycle_purge": lifecycle["purge"],
+            "lifecycle_filesystem_security": lifecycle["filesystem_security"],
         }
 
 

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/forge_autonomy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forge-autonomy
-Version: 2.7.36
+Version: 2.7.37
 Summary: Forge mission planning, producer contracts, and evidence interpretation runtime.
 Author: Forge maintainers
 License-Expression: Apache-2.0

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/product-version.json

@@ -1,5 +1,5 @@
 {
   "product": "forge",
   "schema_version": 1,
-  "version": "2.7.36"
+  "version": "2.7.37"
 }

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/tests/test_installed_lifecycle.py

@@ -251,6 +251,35 @@ class UninstallDispatcherTests(InstalledLifecycleFixture):
             InstalledUninstallDispatcher(self.uninstall_request()).run()
         self.assertTrue(self.data_root.exists())
 
+    def test_hardlinked_file_fails_closed(self) -> None:
+        foreign = self.root / "foreign-hardlink-source"
+        foreign.write_text("foreign", encoding="utf-8")
+        (self.data_root / "unsafe-hardlink").hardlink_to(foreign)
+        self.assertEqual((self.data_root / "unsafe-hardlink").stat().st_nlink, 2)
+        with self.assertRaisesRegex(InstalledLifecycleError, "hardlinked"):
+            InstalledUninstallDispatcher(self.uninstall_request()).run()
+        self.assertTrue(self.data_root.exists())
+
+    def test_group_or_world_writable_tree_fails_closed(self) -> None:
+        self.data_root.chmod(0o777)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledUninstallDispatcher(self.uninstall_request(operation_id="unsafe-root")).run()
+        self.data_root.chmod(0o700)
+
+        unsafe_directory = self.data_root / "unsafe-directory"
+        unsafe_directory.mkdir(mode=0o700)
+        unsafe_directory.chmod(0o772)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledUninstallDispatcher(self.uninstall_request(operation_id="unsafe-directory")).run()
+        unsafe_directory.chmod(0o700)
+
+        unsafe_file = self.data_root / "unsafe-file"
+        unsafe_file.write_text("unsafe", encoding="utf-8")
+        unsafe_file.chmod(0o666)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledUninstallDispatcher(self.uninstall_request(operation_id="unsafe-file")).run()
+        self.assertTrue(self.data_root.exists())
+
     @unittest.skipIf(fcntl is None, "POSIX lock qualification")
     def test_live_server_lock_blocks_uninstall(self) -> None:
         lock = (self.data_root / "locks" / "forge-server-runtime.lock").open("a+")

{forge_autonomy-2.7.36 → forge_autonomy-2.7.37}/tests/test_preserved_lifecycle.py

@@ -96,6 +96,48 @@ class PreservedLifecycleTests(unittest.TestCase):
                 self.restore_request("restore-0001", "preserve-0001")
             ).run()
 
+    def test_preserve_rejects_hardlinks_and_insecure_modes(self) -> None:
+        foreign = self.root / "foreign-hardlink-source"
+        foreign.write_text("foreign", encoding="utf-8")
+        (self.data_root / "unsafe-hardlink").hardlink_to(foreign)
+        with self.assertRaisesRegex(InstalledLifecycleError, "hardlinked"):
+            InstalledPreserveDispatcher(self.request("preserve-hardlink")).run()
+        (self.data_root / "unsafe-hardlink").unlink()
+
+        self.data_root.chmod(0o777)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledPreserveDispatcher(self.request("preserve-root-mode")).run()
+        self.data_root.chmod(0o700)
+
+        unsafe_directory = self.data_root / "unsafe-directory"
+        unsafe_directory.mkdir(mode=0o700)
+        unsafe_directory.chmod(0o772)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledPreserveDispatcher(self.request("preserve-directory-mode")).run()
+        unsafe_directory.chmod(0o700)
+
+        unsafe_file = self.data_root / "unsafe-file"
+        unsafe_file.write_text("unsafe", encoding="utf-8")
+        unsafe_file.chmod(0o666)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledPreserveDispatcher(self.request("preserve-file-mode")).run()
+
+    def test_restore_rejects_insecure_mode_drift_after_preserve(self) -> None:
+        InstalledPreserveDispatcher(self.request("preserve-mode-drift")).run()
+        self.data_root.chmod(0o777)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledRestoreDispatcher(
+                self.restore_request("restore-mode-drift", "preserve-mode-drift")
+            ).run()
+
+    def test_purge_rejects_unsafe_tree_before_destructive_boundary(self) -> None:
+        unsafe = self.data_root / "unsafe-file"
+        unsafe.write_text("unsafe", encoding="utf-8")
+        unsafe.chmod(0o666)
+        with self.assertRaisesRegex(InstalledLifecycleError, "group/world writable"):
+            InstalledPurgeDispatcher(self.request("purge-unsafe")).run()
+        self.assertTrue(self.data_root.exists())
+
     def test_restore_rejects_source_or_artifact_identity_drift(self) -> None:
         InstalledPreserveDispatcher(self.request("preserve-0001")).run()
         request = self.restore_request("restore-drift", "preserve-0001")