Skip to content

The most powerful and modular diffusion model GUI, api and backend with a graph/nodes interface. The fastest local inference engine in the world.

Fix SVG previews broken by the stored-XSS forced-download (#15149)

Matt Miller9cf91339b708
diff --git a/app/assets/api/routes.py b/app/assets/api/routes.py
index 43e60094c..e25b8a57f 100644
--- a/app/assets/api/routes.py
+++ b/app/assets/api/routes.py
@@ -315,15 +315,29 @@ async def download_asset_content(request: web.Request) -> web.Response:
404, "FILE_NOT_FOUND", "Underlying file not found on disk."
)
- # User-controlled asset content must never render inline in the app origin
+ # User-controlled asset content must not render inline in the app origin
# (stored XSS via SVG/HTML/XML). Force dangerous types to download and
- # override any requested inline disposition. Centralised through
- # folder_paths.is_dangerous_content_type so this can't drift from /view and
- # /userdata (the previous inline set here omitted image/svg+xml and missed
- # the charset/casing/+xml-dialect bypasses).
+ # override any requested inline disposition; SVG loaded into an <img> is
+ # exempt, see renders_safely_as_image. Centralised through folder_paths so
+ # this can't drift from /view and /userdata (the previous inline set here
+ # omitted image/svg+xml and missed the charset/casing/+xml-dialect bypasses).
+ extra_headers = {}
+ sec_fetch_dest = request.headers.get("Sec-Fetch-Dest")
if folder_paths.is_dangerous_content_type(content_type):
- content_type = "application/octet-stream"
- disposition = "attachment"
+ # This response now depends on a request header, so it must not be
+ # reused across destinations by a browser or intermediary cache: an
+ # inline SVG primed by an <img> fetch and replayed to a document
+ # navigation of the same URL would re-enable the stored XSS.
+ extra_headers["Vary"] = "Sec-Fetch-Dest"
+ extra_headers["Cache-Control"] = "no-store"
+ if not folder_paths.renders_safely_as_image(content_type, sec_fetch_dest):
+ content_type = "application/octet-stream"
+ disposition = "attachment"
+
+ # mime_type is uploader-supplied and unvalidated, so it can carry
+ # parameters. aiohttp rejects a charset in the content_type argument with
+ # ValueError, which would turn a valid inline SVG into a 500.
+ content_type = content_type.split(";", 1)[0].strip() or "application/octet-stream"
safe_name = (filename or "").replace("\r", "").replace("\n", "")
encoded = urllib.parse.quote(safe_name)
@@ -356,6 +370,7 @@ async def download_asset_content(request: web.Request) -> web.Response:
"Content-Disposition": cd,
"Content-Length": str(file_size),
"X-Content-Type-Options": "nosniff",
+ **extra_headers,
},
)
diff --git a/folder_paths.py b/folder_paths.py
index bd3f25095..df53542dc 100644
--- a/folder_paths.py
+++ b/folder_paths.py
@@ -306,6 +306,23 @@ def is_dangerous_content_type(content_type: str | None) -> bool:
return normalized.endswith('+xml') or normalized.endswith('/xml')
+def renders_safely_as_image(content_type: str | None, sec_fetch_dest: str | None) -> bool:
+ """Return True if a dangerous `content_type` is safe to serve inline anyway.
+
+ An SVG referenced by an ``<img>`` is loaded in secure static mode: scripts
+ and external references are disabled, so the stored XSS that
+ ``is_dangerous_content_type`` guards against cannot fire. The attack needs
+ the SVG to become a document, which is a separate ``Sec-Fetch-Dest``.
+ Browsers set that header themselves and script cannot override it (the
+ ``Sec-`` prefix makes it a forbidden header name), so it is trustworthy for
+ this decision. Anything else, including a missing header from a non-browser
+ client or a proxy that strips it, fails closed.
+ """
+ if sec_fetch_dest != 'image':
+ return False
+ return (content_type or '').split(';', 1)[0].strip().lower() == 'image/svg+xml'
+
+
def is_within_directory(directory: str, target: str) -> bool:
"""Return True if `target` resolves to a path inside `directory`.
diff --git a/server.py b/server.py
index e28fe2d22..c9ffcaa0d 100644
--- a/server.py
+++ b/server.py
@@ -624,8 +624,9 @@ class PromptServer():
# For security, force renderable/active types (HTML, JS,
# CSS, SVG, XML — anything that can carry inline <script>
# and execute in the page origin) to download instead of
- # displaying inline, preventing stored XSS. The
- # attachment disposition is the load-bearing guard: a
+ # displaying inline, preventing stored XSS. SVG loaded
+ # into an <img> is exempt, see renders_safely_as_image.
+ # The attachment disposition is the load-bearing guard: a
# bare filename= hint does not force a download per
# RFC 6266, so we only attach it on the dangerous branch
# to avoid breaking inline display of legitimate images.
@@ -635,18 +636,27 @@ class PromptServer():
# header's quoted-string and malform the disposition.
safe_filename = filename.replace("\\", "\\\\").replace('"', '\\"')
disposition = f"filename=\"{safe_filename}\""
+ headers = {"X-Content-Type-Options": "nosniff"}
+ sec_fetch_dest = request.headers.get('Sec-Fetch-Dest')
if folder_paths.is_dangerous_content_type(content_type):
- content_type = 'application/octet-stream'
- disposition = f"attachment; filename=\"{safe_filename}\""
-
- return web.FileResponse(
- file,
- headers={
- "Content-Disposition": disposition,
- "Content-Type": content_type,
- "X-Content-Type-Options": "nosniff"
- }
- )
+ # This response now depends on a request header, so
+ # it must not be reused across destinations.
+ # FileResponse emits Last-Modified/ETag and nothing
+ # sets Cache-Control on /view, which makes it
+ # heuristically cacheable: without these headers a
+ # cache could replay the inline SVG served to an
+ # <img> to a later document navigation of the same
+ # URL and re-enable the stored XSS, or replay the
+ # attachment to an <img> and re-break the preview.
+ headers["Vary"] = "Sec-Fetch-Dest"
+ headers["Cache-Control"] = "no-store"
+ if not folder_paths.renders_safely_as_image(content_type, sec_fetch_dest):
+ content_type = 'application/octet-stream'
+ disposition = f"attachment; filename=\"{safe_filename}\""
+
+ headers["Content-Disposition"] = disposition
+ headers["Content-Type"] = content_type
+ return web.FileResponse(file, headers=headers)
return web.Response(status=404)
diff --git a/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py b/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py
new file mode 100644
index 000000000..e0964e0db
--- /dev/null
+++ b/tests-unit/security_test/test_ghsa_779p_06_inline_svg_image_dest.py
@@ -0,0 +1,191 @@
+"""CI unit guard for the Sec-Fetch-Dest exemption to FIX #5 of GHSA-779p-m5rp-r4h4.
+
+FIX #5 forced every SVG served by /view and the assets download route to
+application/octet-stream + Content-Disposition: attachment. That blocked the
+stored XSS, but it also stopped SVG node outputs and Media Assets thumbnails
+from rendering, because the frontend requests them with a plain <img>.
+
+An SVG referenced by an <img> is loaded in secure static mode: scripting and
+external references are disabled, so the payload from vuln #5 cannot execute.
+The attack needs the SVG to load as a document, which arrives with a different
+Sec-Fetch-Dest. Browsers set that header themselves and page script cannot
+override it, so renders_safely_as_image() uses it to re-allow only the <img>
+case. Everything else, including a missing header, keeps the forced download.
+
+Because the decision reads a request header, the response must also carry
+Vary: Sec-Fetch-Dest and Cache-Control: no-store. Without them a cache keyed on
+the URL alone can replay the inline SVG served to an <img> to a later document
+navigation of the same URL, which re-enables the very XSS the exemption is
+built around. The route tests at the bottom pin those headers.
+
+server.py cannot be imported in a unit test (importing it spins up the full
+PromptServer/aiohttp app and its global side effects), so the /view side is
+covered by pinning the helper its closure calls.
+"""
+
+import pytest
+from aiohttp import web
+
+import folder_paths
+from app.assets.api import routes as asset_routes
+from app.assets.services.schemas import DownloadResolutionResult
+
+
+# Every Sec-Fetch-Dest that must keep the forced download. 'document' is the
+# vuln #5 attack itself; the rest either cannot execute an SVG or have no
+# reason to receive one inline. None covers curl and proxies that strip the
+# header.
+UNSAFE_DESTS = [
+ 'document',
+ 'iframe',
+ 'object',
+ 'embed',
+ 'frame',
+ 'script',
+ 'style',
+ 'empty',
+ '',
+ None,
+]
+
+
+def test_svg_renders_inline_for_image_dest():
+ assert folder_paths.renders_safely_as_image('image/svg+xml', 'image')
+
+
+def test_svg_forced_to_download_for_every_other_dest():
+ for dest in UNSAFE_DESTS:
+ assert not folder_paths.renders_safely_as_image('image/svg+xml', dest), (
+ f"SVG must not be served inline for Sec-Fetch-Dest={dest!r}. Only "
+ "an <img> load is safe, everything else can reach document context"
+ )
+
+
+def test_missing_header_fails_closed():
+ assert not folder_paths.renders_safely_as_image('image/svg+xml', None)
+
+
+def test_exemption_normalises_parameters_and_casing():
+ for content_type in ('IMAGE/SVG+XML', 'image/svg+xml; charset=utf-8', ' image/svg+xml '):
+ assert folder_paths.renders_safely_as_image(content_type, 'image'), (
+ f"{content_type!r} is an SVG and must not be excluded from the "
+ "exemption by casing or a charset parameter"
+ )
+
+
+def test_other_dangerous_types_are_never_exempt():
+ # Only SVG is safe as an <img>. Nothing else in the blocklist may ride the
+ # image dest back into an inline response.
+ for content_type in ('text/html', 'text/javascript', 'text/css',
+ 'application/xml', 'text/xml', 'application/xhtml+xml',
+ 'image/svg+xml.html', 'application/rss+xml'):
+ assert not folder_paths.renders_safely_as_image(content_type, 'image'), (
+ f"{content_type!r} must stay forced-download regardless of Sec-Fetch-Dest"
+ )
+
+
+def test_exemption_does_not_widen_the_blocklist():
+ # The exemption is a call-site gate, not a change to what counts as
+ # dangerous. is_dangerous_content_type must still flag SVG on its own.
+ assert folder_paths.is_dangerous_content_type('image/svg+xml')
+
+
+# --- Response-level guards on the assets content route -----------------------
+#
+# The helper above decides correctly, but the exemption is only safe if the
+# response cannot be reused across Sec-Fetch-Dest values. These mount the real
+# route and assert on the headers that actually ship.
+
+SVG_PAYLOAD = b'<svg xmlns="http://www.w3.org/2000/svg"><script>alert(1)</script></svg>'
+ASSET_ID = "00000000-0000-4000-8000-000000000001"
+CONTENT_URL = f"/api/assets/{ASSET_ID}/content"
+
+
+class _StubUserManager:
+ def get_request_user_id(self, request):
+ return "test-user"
+
+
+def asset_app(monkeypatch, tmp_path):
+ """Mount the real /api/assets/{id}/content route over a stored SVG."""
+
+ def _factory(stored_mime_type):
+ svg = tmp_path / "thumb.svg"
+ svg.write_bytes(SVG_PAYLOAD)
+
+ monkeypatch.setattr(asset_routes, "_ASSETS_ENABLED", True)
+ monkeypatch.setattr(asset_routes, "USER_MANAGER", _StubUserManager())
+ monkeypatch.setattr(
+ asset_routes,
+ "resolve_asset_for_download",
+ lambda reference_id, owner_id: DownloadResolutionResult(
+ abs_path=str(svg),
+ content_type=stored_mime_type,
+ download_name="thumb.svg",
+ ),
+ )
+
+ app = web.Application()
+ app.add_routes(asset_routes.ROUTES)
+ return app
+
+ return _factory
+
+
+async def test_inline_svg_response_is_not_cacheable_across_destinations(
+ aiohttp_client, asset_app
+):
+ client = await aiohttp_client(asset_app("image/svg+xml"))
+ resp = await client.get(
+ CONTENT_URL, params={"disposition": "inline"}, headers={"Sec-Fetch-Dest": "image"}
+ )
+
+ assert resp.status == 200
+ assert "image/svg+xml" in resp.headers.get("Content-Type", "").lower()
+ # The load-bearing assertion: a cache must not be able to hand this inline
+ # SVG to a later document navigation of the same URL.
+ assert "sec-fetch-dest" in resp.headers.get("Vary", "").lower(), (
+ "The response varies on Sec-Fetch-Dest but does not say so, so a cache "
+ "keyed on the URL alone can replay the inline SVG into document context."
+ )
+ assert "no-store" in resp.headers.get("Cache-Control", "").lower()
+
+
+async def test_forced_download_response_also_declares_the_variance(
+ aiohttp_client, asset_app
+):
+ # The attachment branch needs the same headers, in both directions: a
+ # cached octet-stream replayed to an <img> re-breaks the preview this fix
+ # exists to restore.
+ client = await aiohttp_client(asset_app("image/svg+xml"))
+ resp = await client.get(
+ CONTENT_URL,
+ params={"disposition": "inline"},
+ headers={"Sec-Fetch-Dest": "document"},
+ )
+
+ assert resp.status == 200
+ assert "application/octet-stream" in resp.headers.get("Content-Type", "").lower()
+ assert "attachment" in resp.headers.get("Content-Disposition", "").lower()
+ assert "sec-fetch-dest" in resp.headers.get("Vary", "").lower()
+ assert "no-store" in resp.headers.get("Cache-Control", "").lower()
+
+
+async def test_parameterised_svg_mime_type_does_not_500(aiohttp_client, asset_app):
+ # mime_type is uploader-supplied and unvalidated. aiohttp rejects a charset
+ # in the content_type argument with ValueError, so the exempt branch must
+ # strip parameters before building the response.
+ client = await aiohttp_client(asset_app("image/svg+xml; charset=utf-8"))
+ resp = await client.get(
+ CONTENT_URL, params={"disposition": "inline"}, headers={"Sec-Fetch-Dest": "image"}
+ )
+
+ assert resp.status == 200, (
+ "A charset parameter on the stored mime type must not turn a valid "
+ "inline SVG request into a 500."
+ )
+ assert "image/svg+xml" in resp.headers.get("Content-Type", "").lower()