diff --git a/cms/envs/test.py b/cms/envs/test.py
index b4d32a8aecc5..afa96990677f 100644
--- a/cms/envs/test.py
+++ b/cms/envs/test.py
@@ -240,3 +240,8 @@
 INACTIVE_USER_URL = "http://localhost:18010"
 POLICY_CHANGE_GRADES_ROUTING_KEY = "edx.lms.core.default"
 SINGLE_LEARNER_COURSE_REGRADE_ROUTING_KEY = "edx.lms.core.default"
+
+# lms/envs/test.py sets this; the CMS side never has, but embed_block_view (used to preview
+# library content, including from Studio) reads settings.CORS_ORIGIN_WHITELIST directly with
+# no fallback, so any test that exercises it fails with an AttributeError unless this is set.
+CORS_ORIGIN_WHITELIST = []
diff --git a/cms/static/js/views/modals/preview_v2_library_changes.js b/cms/static/js/views/modals/preview_v2_library_changes.js
index 943fe103220e..2f65bc65756f 100644
--- a/cms/static/js/views/modals/preview_v2_library_changes.js
+++ b/cms/static/js/views/modals/preview_v2_library_changes.js
@@ -65,7 +65,7 @@ function($, _, gettext, BaseModal, ViewUtils) {
 
         getContentHtml: function() {
             return `
-                <iframe src="${this.courseAuthoringMfeUrl}/legacy/preview-changes/${this.upstreamBlockId}?old=${this.upstreamBlockVersionSynced}">
+                <iframe src="${this.courseAuthoringMfeUrl}/legacy/preview-changes/${this.upstreamBlockId}?old=${this.upstreamBlockVersionSynced}&downstream_block_id=${this.downstreamBlockId}">
             `;
         },
 
diff --git a/openedx/core/djangoapps/authz/decorators.py b/openedx/core/djangoapps/authz/decorators.py
index f72a214f92a9..8046d6471589 100644
--- a/openedx/core/djangoapps/authz/decorators.py
+++ b/openedx/core/djangoapps/authz/decorators.py
@@ -6,12 +6,15 @@
 from django.contrib.auth.models import AbstractUser
 from opaque_keys import InvalidKeyError
 from opaque_keys.edx.keys import CourseKey, UsageKey
+from opaque_keys.edx.locator import LibraryContainerLocator, LibraryUsageLocatorV2
 from openedx_authz import api as authz_api
 from rest_framework import status
 
 from common.djangoapps.student.roles import enable_authz_course_authoring
 from openedx.core.djangoapps.authz.constants import LEGACY_PERMISSION_HANDLER_MAP, LegacyAuthoringPermission
 from openedx.core.lib.api.view_utils import DeveloperErrorViewMixin
+from xmodule.modulestore.django import modulestore
+from xmodule.modulestore.exceptions import ItemNotFoundError
 
 log = logging.getLogger(__name__)
 
@@ -124,3 +127,66 @@ def get_course_key(course_id: str) -> CourseKey:
         # Attempt to parse it as such and extract the course key.
         usage_key = UsageKey.from_string(course_id)
         return usage_key.course_key
+
+
+def user_has_course_permission_for_upstream(
+    request,
+    authz_permission: str,
+    upstream_key,
+    param_name: str = "downstream_block_id",
+) -> bool:
+    """
+    Check an AuthZ course permission for the course of a downstream block, but only if
+    that downstream's upstream link actually points at ``upstream_key``.
+
+    Meant for endpoints that are normally scoped to a library resource (``upstream_key``,
+    a ``LibraryUsageLocatorV2`` or ``LibraryContainerLocator``) but should also grant
+    access to a user reviewing that exact resource from a course they can't otherwise
+    view the library from, e.g. a Course Auditor reviewing pending library updates. The
+    caller is expected to fall back to its regular resource-level permission check when
+    this returns False.
+
+    The query param must be the *downstream block's* usage key, not a bare course id: we
+    resolve its real upstream link and compare it against ``upstream_key`` ourselves,
+    rather than trusting the caller's claim that the two are related. Otherwise, holding
+    the permission in any course would grant access to any library resource, whether or
+    not that course actually uses it.
+
+    Returns False (never raises) for any reason the bypass doesn't apply: the param is
+    absent, not a valid usage key, the downstream doesn't exist, has no upstream link, or
+    that link doesn't match ``upstream_key``.
+
+    Deliberately doesn't use cms.lib.xblock.upstream_sync.UpstreamLink: this module is a
+    dependency of low-level apps like content_libraries and xblock (per the "low-level
+    apps should not depend on high-level apps" import-linter contract), so it can't import
+    from upstream_sync without creating a cycle. We only need the raw upstream reference,
+    so we read the block's ``upstream`` field directly (relying on it having the mixin
+    that provides that field applied elsewhere, not on importing that mixin ourselves) and
+    parse it ourselves, the same way UpstreamLink.get_for_block does internally.
+    """
+    downstream_id = request.GET.get(param_name)
+    if not downstream_id:
+        return False
+    try:
+        downstream_key = UsageKey.from_string(downstream_id)
+    except InvalidKeyError:
+        return False
+    try:
+        downstream = modulestore().get_item(downstream_key)
+    except ItemNotFoundError:
+        return False
+
+    upstream_ref = getattr(downstream, "upstream", None)
+    if not upstream_ref:
+        return False
+    try:
+        downstream_upstream_key = LibraryUsageLocatorV2.from_string(upstream_ref)
+    except InvalidKeyError:
+        try:
+            downstream_upstream_key = LibraryContainerLocator.from_string(upstream_ref)
+        except InvalidKeyError:
+            return False
+
+    if downstream_upstream_key != upstream_key:
+        return False
+    return user_has_course_permission(request.user, authz_permission, downstream_key.course_key)
diff --git a/openedx/core/djangoapps/authz/tests/test_decorators.py b/openedx/core/djangoapps/authz/tests/test_decorators.py
index 78aa923ceb8c..be4bc4ad287d 100644
--- a/openedx/core/djangoapps/authz/tests/test_decorators.py
+++ b/openedx/core/djangoapps/authz/tests/test_decorators.py
@@ -2,15 +2,23 @@
 from unittest.mock import Mock, patch
 
 from django.test import RequestFactory, TestCase
-from opaque_keys.edx.locator import BlockUsageLocator, CourseLocator
+from opaque_keys.edx.locator import (
+    BlockUsageLocator,
+    CourseLocator,
+    LibraryContainerLocator,
+    LibraryLocatorV2,
+    LibraryUsageLocatorV2,
+)
 
 from openedx.core.djangoapps.authz.constants import LegacyAuthoringPermission
 from openedx.core.djangoapps.authz.decorators import (
     authz_permission_required,
     get_course_key,
     user_has_course_permission,
+    user_has_course_permission_for_upstream,
 )
 from openedx.core.lib.api.view_utils import DeveloperErrorResponseException
+from xmodule.modulestore.exceptions import ItemNotFoundError
 
 
 class AuthzPermissionRequiredDecoratorTests(TestCase):
@@ -240,3 +248,155 @@ def test_usage_key_string(self):
         result = get_course_key(str(usage_key))
 
         self.assertEqual(result, self.course_key)  # noqa: PT009
+
+
+class UserHasCoursePermissionForUpstreamTests(TestCase):
+    """Tests for user_has_course_permission_for_upstream."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.course_key = CourseLocator("TestX", "TST101", "2025")
+        self.downstream_key = BlockUsageLocator(self.course_key, "html", "downstream1")
+        self.library_key = LibraryLocatorV2(org="TestX", slug="lib1")
+        self.upstream_key = LibraryUsageLocatorV2(self.library_key, block_type="html", usage_id="upstream1")
+        self.user = Mock()
+
+    def test_missing_param_denies_without_loading_anything(self):
+        """No query param at all means the bypass doesn't apply."""
+        request = self.factory.get("/test")
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore:
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_modulestore.assert_not_called()
+
+    def test_invalid_usage_key_denies_without_loading_anything(self):
+        """A malformed usage key is treated as absent, not as an error."""
+        request = self.factory.get("/test", {"downstream_block_id": "not-a-real-key"})
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore:
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_modulestore.assert_not_called()
+
+    def test_downstream_not_found_denies(self):
+        """If the downstream block doesn't exist, the bypass doesn't apply."""
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.side_effect = ItemNotFoundError
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_check.assert_not_called()
+
+    def test_downstream_with_no_upstream_link_denies(self):
+        """If the downstream has no upstream field set at all, the bypass doesn't apply."""
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.return_value = Mock(spec=["usage_key"])
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_check.assert_not_called()
+
+    def test_downstream_with_malformed_upstream_denies(self):
+        """If the downstream's upstream field isn't a parseable library key, deny."""
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.return_value = Mock(upstream="not-a-real-key")
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_check.assert_not_called()
+
+    def test_mismatched_upstream_denies(self):
+        """
+        If the downstream links to a *different* upstream than the one being requested,
+        the bypass doesn't apply. This is the crux of the fix for openedx-authz#441: holding
+        the course permission isn't enough by itself, the linked resource has to match.
+        """
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+        unrelated_upstream_key = LibraryUsageLocatorV2(self.library_key, block_type="html", usage_id="other")
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.return_value = Mock(upstream=str(unrelated_upstream_key))
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is False
+        mock_check.assert_not_called()
+
+    def test_matching_upstream_delegates_to_permission_check(self):
+        """If the downstream's upstream link matches, we check the course permission."""
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+        request.user = self.user
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+            return_value=True,
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.return_value = Mock(upstream=str(self.upstream_key))
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key,
+            )
+
+        assert result is True
+        mock_check.assert_called_once_with(self.user, "courses.view_library_updates", self.course_key)
+
+    def test_matching_container_upstream_delegates_to_permission_check(self):
+        """Same as above, but the upstream is a container (unit/subsection/section), not a block."""
+        container_key = LibraryContainerLocator(self.library_key, container_type="unit", container_id="upstream-unit")
+        request = self.factory.get("/test", {"downstream_block_id": str(self.downstream_key)})
+        request.user = self.user
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+            return_value=True,
+        ) as mock_check:
+            mock_modulestore.return_value.get_item.return_value = Mock(upstream=str(container_key))
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", container_key,
+            )
+
+        assert result is True
+        mock_check.assert_called_once_with(self.user, "courses.view_library_updates", self.course_key)
+
+    def test_custom_param_name(self):
+        """The query param name can be overridden."""
+        request = self.factory.get("/test", {"downstream_id": str(self.downstream_key)})
+        request.user = self.user
+
+        with patch("openedx.core.djangoapps.authz.decorators.modulestore") as mock_modulestore, patch(
+            "openedx.core.djangoapps.authz.decorators.user_has_course_permission",
+            return_value=True,
+        ):
+            mock_modulestore.return_value.get_item.return_value = Mock(upstream=str(self.upstream_key))
+            result = user_has_course_permission_for_upstream(
+                request, "courses.view_library_updates", self.upstream_key, param_name="downstream_id",
+            )
+
+        assert result is True
diff --git a/openedx/core/djangoapps/content_libraries/rest_api/blocks.py b/openedx/core/djangoapps/content_libraries/rest_api/blocks.py
index c440488c38e5..d58138891f8d 100644
--- a/openedx/core/djangoapps/content_libraries/rest_api/blocks.py
+++ b/openedx/core/djangoapps/content_libraries/rest_api/blocks.py
@@ -22,6 +22,7 @@
 from rest_framework.views import APIView
 
 import openedx.core.djangoapps.site_configuration.helpers as configuration_helpers
+from openedx.core.djangoapps.authz.decorators import user_has_course_permission_for_upstream
 from openedx.core.djangoapps.content_libraries import api, permissions
 from openedx.core.djangoapps.content_libraries.rest_api import serializers
 from openedx.core.djangoapps.xblock import api as xblock_api
@@ -122,7 +123,10 @@ def get(self, request, usage_key_str):
         versioning.
         """
         key = LibraryUsageLocatorV2.from_string(usage_key_str)
-        api.require_permission_for_library_key(key.lib_key, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY)
+        if not user_has_course_permission_for_upstream(
+            request, authz_permissions.COURSES_VIEW_LIBRARY_UPDATES.identifier, key
+        ):
+            api.require_permission_for_library_key(key.lib_key, request.user, permissions.CAN_VIEW_THIS_CONTENT_LIBRARY)
         result = api.get_library_block(key, include_collections=True)
 
         return Response(self.serializer_class(result).data)
diff --git a/openedx/core/djangoapps/content_libraries/rest_api/containers.py b/openedx/core/djangoapps/content_libraries/rest_api/containers.py
index e415620e59fd..fe0fb2a508e2 100644
--- a/openedx/core/djangoapps/content_libraries/rest_api/containers.py
+++ b/openedx/core/djangoapps/content_libraries/rest_api/containers.py
@@ -20,6 +20,7 @@
 from rest_framework.status import HTTP_200_OK, HTTP_204_NO_CONTENT
 from rest_framework.views import APIView
 
+from openedx.core.djangoapps.authz.decorators import user_has_course_permission_for_upstream
 from openedx.core.djangoapps.content_libraries import api, permissions
 from openedx.core.lib.api.view_utils import view_auth_classes
 from openedx.core.types.http import RestRequest
@@ -81,11 +82,14 @@ def get(self, request, container_key: LibraryContainerLocator):
         """
         Get information about a container
         """
-        api.require_permission_for_library_key(
-            container_key.lib_key,
-            request.user,
-            permissions.CAN_VIEW_THIS_CONTENT_LIBRARY,
-        )
+        if not user_has_course_permission_for_upstream(
+            request, authz_permissions.COURSES_VIEW_LIBRARY_UPDATES.identifier, container_key
+        ):
+            api.require_permission_for_library_key(
+                container_key.lib_key,
+                request.user,
+                permissions.CAN_VIEW_THIS_CONTENT_LIBRARY,
+            )
         container = api.get_container(container_key, include_collections=True)
         return Response(serializers.LibraryContainerMetadataSerializer(container).data)
 
@@ -186,11 +190,14 @@ def get(self, request, container_key: LibraryContainerLocator):
         ]
         """
         published = request.GET.get('published', 'false').lower() == 'true'
-        api.require_permission_for_library_key(
-            container_key.lib_key,
-            request.user,
-            permissions.CAN_VIEW_THIS_CONTENT_LIBRARY,
-        )
+        if not user_has_course_permission_for_upstream(
+            request, authz_permissions.COURSES_VIEW_LIBRARY_UPDATES.identifier, container_key
+        ):
+            api.require_permission_for_library_key(
+                container_key.lib_key,
+                request.user,
+                permissions.CAN_VIEW_THIS_CONTENT_LIBRARY,
+            )
         child_entities = api.get_container_children(container_key, published=published)
         if container_key.container_type == content_models.Unit.type_code:
             data = serializers.LibraryXBlockMetadataSerializer(child_entities, many=True).data
diff --git a/openedx/core/djangoapps/content_libraries/tests/test_containers.py b/openedx/core/djangoapps/content_libraries/tests/test_containers.py
index 3900234f1db5..7ae70e5b54b9 100644
--- a/openedx/core/djangoapps/content_libraries/tests/test_containers.py
+++ b/openedx/core/djangoapps/content_libraries/tests/test_containers.py
@@ -8,12 +8,20 @@
 import ddt
 from freezegun import freeze_time
 from opaque_keys.edx.locator import LibraryContainerLocator, LibraryLocatorV2, LibraryUsageLocatorV2
+from openedx_authz.constants.roles import COURSE_AUDITOR
 
 from common.djangoapps.student.tests.factories import UserFactory
+from openedx.core.djangoapps.authz.tests.mixins import CourseAuthoringAuthzTestMixin
 from openedx.core.djangoapps.content_libraries import api
-from openedx.core.djangoapps.content_libraries.tests.base import ContentLibrariesRestApiTest
+from openedx.core.djangoapps.content_libraries.tests.base import (
+    URL_LIB_CONTAINER,
+    URL_LIB_CONTAINER_CHILDREN,
+    ContentLibrariesRestApiTest,
+)
 from openedx.core.djangoapps.content_tagging import api as tagging_api
 from openedx.core.djangolib.testing.utils import skip_unless_cms
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import BlockFactory, CourseFactory
 
 
 @skip_unless_cms
@@ -1322,3 +1330,101 @@ def test_container_draft_history_permissions(self):
         unauthorized = UserFactory.create(username="noauth-container-hist", password="edx")
         with self.as_user(unauthorized):
             self._get_container_draft_history(unit["id"], expect_response=403)
+
+
+@skip_unless_cms
+class ContainerLibraryUpdatesAuthzBypassTest(
+    CourseAuthoringAuthzTestMixin, ContentLibrariesRestApiTest, ModuleStoreTestCase,
+):
+    """
+    A course auditor has no direct permissions on the library backing a unit they're
+    reviewing, but does hold `courses.view_library_updates` in the course. Passing the
+    linked downstream unit's usage key as `course_id` should let them view the upstream
+    container/children anyway, but only because that specific downstream is actually
+    linked to it: holding the permission in the course alone isn't enough.
+
+    See openedx-authz#441.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create()
+        self.add_user_to_role_in_course(self.authorized_user, COURSE_AUDITOR.external_key, str(self.course.id))
+
+        self.lib = self._create_library(slug="library-updates-lib", title="Library Updates Test Library")
+        self.container_key = self._create_container(
+            self.lib["id"], "unit", display_name="Reviewable Unit", slug=None,
+        )["id"]
+
+        # Linked to self.container_key: this is the downstream that should grant access.
+        self.linked_downstream_id = str(
+            BlockFactory.create(category="vertical", parent=self.course, upstream=self.container_key).location
+        )
+        # In the same (accessible) course, but not linked to self.container_key at all: this
+        # is what openedx-authz#441 was actually about, holding the course permission must
+        # not be enough on its own, the resource has to be linked to that specific downstream.
+        self.unrelated_downstream_id = str(
+            BlockFactory.create(category="vertical", parent=self.course).location
+        )
+
+    def test_container_detail_denied_without_course_id(self):
+        """A course auditor with no library access is denied when course_id isn't given."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(URL_LIB_CONTAINER.format(container_key=self.container_key))
+        assert response.status_code == 403
+
+    def test_container_detail_allowed_with_linked_downstream(self):
+        """The same course auditor is allowed once course_id points at the linked downstream."""
+        with self.as_user(self.authorized_user):
+            response = self.client.get(
+                URL_LIB_CONTAINER.format(container_key=self.container_key),
+                {"downstream_block_id": self.linked_downstream_id},
+            )
+        assert response.status_code == 200
+
+    def test_container_children_denied_without_course_id(self):
+        """Same as test_container_detail_denied_without_course_id, for the children endpoint."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(URL_LIB_CONTAINER_CHILDREN.format(container_key=self.container_key))
+        assert response.status_code == 403
+
+    def test_container_children_allowed_with_linked_downstream(self):
+        """Same as test_container_detail_allowed_with_linked_downstream, for the children endpoint."""
+        with self.as_user(self.authorized_user):
+            response = self.client.get(
+                URL_LIB_CONTAINER_CHILDREN.format(container_key=self.container_key),
+                {"downstream_block_id": self.linked_downstream_id},
+            )
+        assert response.status_code == 200
+
+    def test_unrelated_course_id_is_denied(self):
+        """A course_id where the user holds no role at all must not grant access."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_LIB_CONTAINER.format(container_key=self.container_key),
+                {"downstream_block_id": "course-v1:CL-TEST+OTHER101+2025"},
+            )
+        assert response.status_code == 403
+
+    def test_downstream_not_linked_to_this_container_is_denied(self):
+        """
+        A downstream in a course the user can review, but that isn't linked to this
+        container, must not grant access. Regression test for openedx-authz#441: the
+        original implementation trusted the course_id alone, so holding the permission in
+        any course was enough to read any library resource, whether or not that course
+        actually used it.
+        """
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_LIB_CONTAINER.format(container_key=self.container_key),
+                {"downstream_block_id": self.unrelated_downstream_id},
+            )
+        assert response.status_code == 403
+
+    def test_library_permission_alone_still_works_without_course_id(self):
+        """
+        Backward compatibility: a user with direct library access (self.user, who created
+        the library) keeps working exactly as before, without ever passing course_id.
+        """
+        response = self.client.get(URL_LIB_CONTAINER.format(container_key=self.container_key))
+        assert response.status_code == 200
diff --git a/openedx/core/djangoapps/content_libraries/tests/test_embed_block.py b/openedx/core/djangoapps/content_libraries/tests/test_embed_block.py
index 8f0fb85eebc8..83836694e703 100644
--- a/openedx/core/djangoapps/content_libraries/tests/test_embed_block.py
+++ b/openedx/core/djangoapps/content_libraries/tests/test_embed_block.py
@@ -8,18 +8,24 @@
 import ddt
 import pytest
 from django.core.exceptions import ValidationError
-from django.test.utils import override_settings
+from openedx_authz.constants.roles import COURSE_AUDITOR
 from xblock.core import XBlock
 
-from openedx.core.djangoapps.content_libraries.tests.base import ContentLibrariesRestApiTest
+from openedx.core.djangoapps.authz.tests.mixins import CourseAuthoringAuthzTestMixin
+from openedx.core.djangoapps.content_libraries.tests.base import (
+    URL_BLOCK_EMBED_VIEW,
+    URL_LIB_BLOCK,
+    ContentLibrariesRestApiTest,
+)
 from openedx.core.djangolib.testing.utils import skip_unless_cms
+from xmodule.modulestore.tests.django_utils import ModuleStoreTestCase
+from xmodule.modulestore.tests.factories import BlockFactory, CourseFactory
 
 from .fields_test_block import FieldsTestBlock
 
 
 @skip_unless_cms
 @ddt.ddt
-@override_settings(CORS_ORIGIN_WHITELIST=[])  # For some reason, this setting isn't defined in our test environment?
 class LibrariesEmbedViewTestCase(ContentLibrariesRestApiTest):
     """
     Tests for embed_view and interacting with draft/published/past versions of
@@ -227,3 +233,154 @@ def test_embed_view_versions_static_assets(self):
 
     # TODO: if we are ever able to run these tests in the LMS, test that the LMS only allows accessing the published
     # version.
+
+
+@skip_unless_cms
+class EmbedViewAuthzBypassTest(CourseAuthoringAuthzTestMixin, ContentLibrariesRestApiTest, ModuleStoreTestCase):
+    """
+    A course auditor has no direct permissions on the library backing a block they're
+    reviewing, but does hold `courses.view_library_updates` in the course. Passing the
+    linked downstream block's usage key as `course_id` should let them view the upstream
+    block's embed anyway, but only because that specific downstream is actually linked to
+    it: holding the permission in the course alone isn't enough.
+
+    See openedx-authz#441.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create()
+        self.add_user_to_role_in_course(self.authorized_user, COURSE_AUDITOR.external_key, str(self.course.id))
+
+        lib = self._create_library(slug="embed-authz-bypass-lib", title="Embed AuthZ Bypass Test Library")
+        create_response = self._add_block_to_library(lib["id"], "html", "block1")
+        self.block_id = create_response["id"]
+        self._set_library_block_olx(self.block_id, "<html>Hello world</html>")
+        self._commit_library_changes(lib["id"])
+
+        # Linked to self.block_id: this is the downstream that should grant access.
+        self.linked_downstream_id = str(
+            BlockFactory.create(category="html", parent=self.course, upstream=self.block_id).location
+        )
+        # In the same (accessible) course, but not linked to self.block_id at all: this is
+        # what openedx-authz#441 was actually about, holding the course permission must not
+        # be enough on its own, the resource has to be linked to that specific downstream.
+        self.unrelated_downstream_id = str(
+            BlockFactory.create(category="html", parent=self.course).location
+        )
+
+    def test_embed_denied_without_course_id(self):
+        """A course auditor with no library access is denied when course_id isn't given."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(URL_BLOCK_EMBED_VIEW.format(block_key=self.block_id, view_name="student_view"))
+        assert response.status_code == 403
+
+    def test_embed_allowed_with_linked_downstream(self):
+        """The same course auditor is allowed once course_id points at the linked downstream."""
+        with self.as_user(self.authorized_user):
+            response = self.client.get(
+                URL_BLOCK_EMBED_VIEW.format(block_key=self.block_id, view_name="student_view"),
+                {"downstream_block_id": self.linked_downstream_id},
+            )
+        assert response.status_code == 200
+
+    def test_unrelated_course_id_is_denied(self):
+        """A course_id where the user holds no role at all must not grant access."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_BLOCK_EMBED_VIEW.format(block_key=self.block_id, view_name="student_view"),
+                {"downstream_block_id": "course-v1:CL-TEST+OTHER101+2025"},
+            )
+        assert response.status_code == 403
+
+    def test_downstream_not_linked_to_this_block_is_denied(self):
+        """
+        A downstream in a course the user can review, but that isn't linked to this block,
+        must not grant access. Regression test for openedx-authz#441: the original
+        implementation trusted the course_id alone, so holding the permission in any course
+        was enough to read any library resource, whether or not that course actually used it.
+        """
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_BLOCK_EMBED_VIEW.format(block_key=self.block_id, view_name="student_view"),
+                {"downstream_block_id": self.unrelated_downstream_id},
+            )
+        assert response.status_code == 403
+
+    def test_library_permission_alone_still_works_without_course_id(self):
+        """
+        Backward compatibility: a user with direct library access (self.user, who created
+        the library) keeps working exactly as before, without ever passing course_id.
+        """
+        response = self.client.get(URL_BLOCK_EMBED_VIEW.format(block_key=self.block_id, view_name="student_view"))
+        assert response.status_code == 200
+
+
+@skip_unless_cms
+class LibraryBlockMetadataAuthzBypassTest(
+    CourseAuthoringAuthzTestMixin, ContentLibrariesRestApiTest, ModuleStoreTestCase,
+):
+    """
+    Same bypass as EmbedViewAuthzBypassTest above, but for LibraryBlockView.get, the
+    metadata endpoint used (among others) to get a block's display name while previewing
+    pending library updates from a course.
+
+    See openedx-authz#441.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.course = CourseFactory.create()
+        self.add_user_to_role_in_course(self.authorized_user, COURSE_AUDITOR.external_key, str(self.course.id))
+
+        lib = self._create_library(slug="block-metadata-authz-bypass-lib", title="Block Metadata AuthZ Bypass Lib")
+        create_response = self._add_block_to_library(lib["id"], "html", "block1")
+        self.block_id = create_response["id"]
+        self._commit_library_changes(lib["id"])
+
+        # Linked to self.block_id: this is the downstream that should grant access.
+        self.linked_downstream_id = str(
+            BlockFactory.create(category="html", parent=self.course, upstream=self.block_id).location
+        )
+        # In the same (accessible) course, but not linked to self.block_id at all.
+        self.unrelated_downstream_id = str(
+            BlockFactory.create(category="html", parent=self.course).location
+        )
+
+    def test_metadata_denied_without_course_id(self):
+        """A course auditor with no library access is denied when course_id isn't given."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(URL_LIB_BLOCK.format(block_key=self.block_id))
+        assert response.status_code == 403
+
+    def test_metadata_allowed_with_linked_downstream(self):
+        """The same course auditor is allowed once course_id points at the linked downstream."""
+        with self.as_user(self.authorized_user):
+            response = self.client.get(
+                URL_LIB_BLOCK.format(block_key=self.block_id),
+                {"downstream_block_id": self.linked_downstream_id},
+            )
+        assert response.status_code == 200
+
+    def test_unrelated_course_id_is_denied(self):
+        """A course_id where the user holds no role at all must not grant access."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_LIB_BLOCK.format(block_key=self.block_id),
+                {"downstream_block_id": "course-v1:CL-TEST+OTHER101+2025"},
+            )
+        assert response.status_code == 403
+
+    def test_downstream_not_linked_to_this_block_is_denied(self):
+        """A downstream in a course the user can review, but that isn't linked to this block, must not grant access."""
+        with self.as_user(self.authorized_user), self.allow_transaction_exception():
+            response = self.client.get(
+                URL_LIB_BLOCK.format(block_key=self.block_id),
+                {"downstream_block_id": self.unrelated_downstream_id},
+            )
+        assert response.status_code == 403
+
+    def test_library_permission_alone_still_works_without_course_id(self):
+        """Backward compatibility: a user with direct library access keeps working as before."""
+        response = self.client.get(URL_LIB_BLOCK.format(block_key=self.block_id))
+        assert response.status_code == 200
diff --git a/openedx/core/djangoapps/xblock/rest_api/views.py b/openedx/core/djangoapps/xblock/rest_api/views.py
index 36fc1b9ae6d1..562e7df71a29 100644
--- a/openedx/core/djangoapps/xblock/rest_api/views.py
+++ b/openedx/core/djangoapps/xblock/rest_api/views.py
@@ -14,6 +14,7 @@
 from django.views.decorators.clickjacking import xframe_options_exempt
 from django.views.decorators.csrf import csrf_exempt
 from opaque_keys.edx.keys import UsageKeyV2
+from openedx_authz.constants.permissions import COURSES_VIEW_LIBRARY_UPDATES
 from rest_framework import permissions, serializers
 from rest_framework.decorators import api_view, permission_classes  # pylint: disable=unused-import
 from rest_framework.exceptions import AuthenticationFailed, NotFound, PermissionDenied
@@ -26,6 +27,7 @@
 
 import openedx.core.djangoapps.site_configuration.helpers as configuration_helpers
 from common.djangoapps.util.json_request import JsonResponse
+from openedx.core.djangoapps.authz.decorators import user_has_course_permission_for_upstream
 from openedx.core.djangoapps.xblock.learning_context.manager import get_learning_context_impl
 from openedx.core.lib.api.view_utils import view_auth_classes
 
@@ -104,8 +106,18 @@ def embed_block_view(request, usage_key: UsageKeyV2, view_name: str):
     except ValueError as exc:
         raise serializers.ValidationError("Invalid version specifier") from exc
 
+    # A user reviewing a library's pending changes from within a course (e.g. a Course
+    # Auditor with courses.view_library_updates) may not have direct access to the
+    # upstream library. That course-level permission substitutes for the regular
+    # library-level check below.
+    check_permission: CheckPerm | None = CheckPerm.CAN_LEARN
+    if user_has_course_permission_for_upstream(
+        request, COURSES_VIEW_LIBRARY_UPDATES.identifier, usage_key
+    ):
+        check_permission = None
+
     try:
-        block = load_block(usage_key, request.user, check_permission=CheckPerm.CAN_LEARN, version=version)
+        block = load_block(usage_key, request.user, check_permission=check_permission, version=version)
     except NoSuchUsage as exc:
         raise NotFound(f"{usage_key} not found") from exc