diff --git a/config/Service.pkl b/config/Service.pkl index 2cb1ccfc7d8fc89e72b824b28181c86f58e0e984..86bbab7343c15881c914746f261244acb9d0bd08 100644 --- a/config/Service.pkl +++ b/config/Service.pkl @@ -19,8 +19,6 @@ class Http { forwardRealIp: Boolean = false /// Require HTTPS when browsers send cookies issued by this route. secureCookies: Boolean = false - /// Require the native Snow sign-in gateway before Jellyfin handles requests. - jellyfinAuth: Boolean = false /// Generated secret whose value becomes the private proxy header name. identityProofSecret: String? /// Additional hosts routed to this container without SSO headers. diff --git a/tools/deploy-test.py b/tools/deploy-test.py index 28995dededbc4d8981121374ade0bf883ec95806..a7809f6eed9c8f7a8804019d68a2fe93d3a86994 100644 --- a/tools/deploy-test.py +++ b/tools/deploy-test.py @@ -40,7 +40,7 @@ class MainExport(unittest.TestCase): subprocess.run(["jj", "new"], cwd=repo, check=True, capture_output=True) (repo / "service/fixture").write_text("unfinished") (repo / "service/new").write_text("new working file") - generated = repo / "service/jellyfin/bridge/tests/bin/Release/net10.0/fixture.dll" + generated = repo / "guest/build/fixture" generated.parent.mkdir(parents=True) digest = release.tree_digest(repo) generated.write_bytes(b"compiled fixture") diff --git a/tools/release.py b/tools/release.py index 6958f06c1ec3268755808b126f6b5669d24693fc..bf9050ab1899e3fee28d34db3137a06c1102a09b 100644 --- a/tools/release.py +++ b/tools/release.py @@ -19,8 +19,7 @@ RELEASES = ROOT / "releases" STATE = Path("/var/lib/snowglobe") HISTORY = STATE / "deployments.json" SOURCES = ("config", "service", "tools", "nixos", "dashboard", "guest", "flake.nix", "flake.lock", "readme.md", "AGENTS.md") -BUILD_DIRS = ("dashboard/node_modules", "dashboard/dist", "dashboard/.cache", "dashboard/data", "dashboard/target", "guest/build", - "service/jellyfin/bridge/bin", "service/jellyfin/bridge/obj", "service/jellyfin/bridge/tests/bin", "service/jellyfin/bridge/tests/obj") +BUILD_DIRS = ("dashboard/node_modules", "dashboard/dist", "dashboard/.cache", "dashboard/data", "dashboard/target", "guest/build") RELEASE_ID = re.compile(r"[0-9a-f]{16}\Z") STAGE_ID = re.compile(r"[a-z][a-z0-9-]*\Z") diff --git a/tools/router-jellyfin-test.py b/tools/router-jellyfin-test.py deleted file mode 100644 index e758f3700540977e7456ef134a71464a296b930d..0000000000000000000000000000000000000000 --- a/tools/router-jellyfin-test.py +++ /dev/null @@ -1,300 +0,0 @@ -#!/usr/bin/env python3 -import argparse -from http.client import HTTPConnection -from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer -import json -import os -import socket -import subprocess -import tempfile -import threading -import time -from pathlib import Path -import unittest -import urllib.parse -from unittest.mock import patch - -import router - - -class Backend(BaseHTTPRequestHandler): - requests = [] - bodies = [] - - def do_GET(self): - type(self).requests.append((self.command, self.path, dict(self.headers))) - type(self).bodies.append(self.rfile.read(int(self.headers.get('Content-Length', '0')))) - if self.headers.get('Upgrade', '').lower() == 'websocket': - self.send_response(101) - self.send_header('Connection', 'Upgrade') - self.send_header('Upgrade', 'websocket') - self.end_headers() - return - self.send_response(206 if self.headers.get('Range') else 200) - self.send_header('Content-Type', 'application/octet-stream') - self.send_header('ETag', '"fixture"') - self.send_header('Content-Length', '5') - if self.headers.get('Range'): - self.send_header('Content-Range', 'bytes 0-4/10') - self.end_headers() - if self.command != 'HEAD': - self.wfile.write(b'hello') - - do_HEAD = do_GET - do_POST = do_GET - - def log_message(self, *_): - pass - - -class Gateway(BaseHTTPRequestHandler): - requests = [] - - def do_GET(self): - size = int(self.headers.get('Content-Length', '0')) - body = self.rfile.read(size) - type(self).requests.append((self.command, self.path, dict(self.headers), body)) - trusted = self.headers.get('Snowglobe-Proxy-Token') == 'a' * 64 - original = self.headers.get('Snowglobe-Jellyfin-Uri', '') - if not trusted: - self.send_error(403) - elif self.path == '/auth/jellyfin/public': - self.send_response(200) - self.send_header('Content-Type', 'application/json') - self.end_headers() - self.wfile.write(json.dumps({'method': self.headers.get('Snowglobe-Jellyfin-Method'), 'body': body.decode()}).encode()) - elif self.headers.get('Authorization') == 'allow' or original.startswith('/Items/' + '1' * 32 + '/Images/Primary'): - self.send_response(204) - path, _, query = original.partition('?') - kept = [part for part in query.split('&') if part and urllib.parse.unquote_plus(part.split('=', 1)[0]).lower() not in {'apikey', 'api_key'}] - self.send_header('X-Snowglobe-Jellyfin-Uri', path + ('?' + '&'.join(kept) if kept else '')) - if self.headers.get('Authorization'): - self.send_header('X-Snowglobe-Jellyfin-Authorization', 'MediaBrowser Token="normalized"') - self.send_header('Set-Cookie', '__Host-snow-jellyfin=normalized; HttpOnly; Secure; Path=/') - self.end_headers() - else: - self.send_error(401) - - do_POST = do_GET - do_OPTIONS = do_GET - - def log_message(self, *_): - pass - - -class GatewayAssociation(unittest.TestCase): - def test_only_tagged_preview_uses_its_own_gateway(self): - with tempfile.TemporaryDirectory(prefix='jellyfin-gateway-') as temporary: - root = Path(temporary) - stages = root / 'stages' - stages.mkdir() - jellyfin = 'jellyfin-preview-1234abcd' - shale = 'shale-preview-5678abcd' - dashboard = 'dashboard-preview-1234abcd' - (stages / (jellyfin + '.json')).write_text(json.dumps({'sourceId': 'jellyfin', 'gatewayStage': dashboard})) - (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale', 'gatewayStage': dashboard})) - mount = root / 'staging' / dashboard - mount.mkdir(parents=True) - proxy_proof = mount / 'proxy.token' - proxy_proof.write_text('b' * 64) - proxy_proof.chmod(0o400) - (stages / (dashboard + '.json')).write_text(json.dumps({'sourceId': 'dashboard', 'mount': str(mount)})) - proof = root / 'proof' - proof.write_text('a' * 64) - services = { - 'jellyfin': (1111, ['caddy-host=jelly.paperclover.net']), - 'copyparty': (1112, ['caddy-host=file.paperclover.net']), - jellyfin: (2222, ['caddy-host=' + jellyfin + '.paperclover.net', 'caddy-jellyfin-auth=true']), - shale: (6666, ['caddy-host=' + shale + '.paperclover.net']), - dashboard: (3333, ['caddy-host=' + dashboard + '.paperclover.net']), - } - - def nomad(path, _): - if path == '/v1/services': - return [{'Namespace': 'default', 'Services': [{'ServiceName': name} for name in services]}] - if path.startswith('/v1/service/'): - name = path.rsplit('/', 1)[1] - port, tags = services[name] - return [{'ServiceName': name, 'JobID': name, 'AllocID': name, 'Address': '127.0.0.1', 'Port': port, 'Tags': tags}] - return {'http': {'Status': 'success'}} - - environment = {'SNOWGLOBE_DOMAIN': 'paperclover.net', 'SNOWGLOBE_DASHBOARD_PORT': '4444', - 'SNOWGLOBE_PROXY_TOKEN_FILE': str(proof), 'SNOWGLOBE_STATE': temporary} - with patch.dict(os.environ, environment, clear=True), patch.object(router, 'nomad', nomad), patch.object(router, 'ROUTE_DIR', str(root / 'routes')): - rendered = router.render('fixture') - legacy = rendered.split('jelly.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - preview = rendered.split(jellyfin + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertNotIn('/auth/jellyfin/', legacy) - self.assertIn('reverse_proxy 127.0.0.1:1111', legacy) - self.assertIn('reverse_proxy 127.0.0.1:3333', preview) - self.assertNotIn('reverse_proxy 127.0.0.1:4444', preview) - self.assertNotIn('a' * 64, preview) - self.assertIn('b' * 64, preview) - dashboard_route = rendered.split(dashboard + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('request_header Snowglobe-Proxy-Token ' + 'b' * 64, dashboard_route) - self.assertNotIn('tracing', preview) - shale_route = rendered.split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('reverse_proxy 127.0.0.1:3333', shale_route) - self.assertIn('Snowglobe-Shale-Upstream "127.0.0.1:6666"', shale_route) - self.assertIn('b' * 64, shale_route) - self.assertNotIn('a' * 64, shale_route) - self.assertNotIn('reverse_proxy 127.0.0.1:4444', shale_route) - (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'jellyfin', 'gatewayStage': dashboard})) - denied = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('respond 503', denied) - self.assertNotIn('/auth/shale/page', denied) - (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale'})) - unbound = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('reverse_proxy 127.0.0.1:4444', unbound) - self.assertIn('a' * 64, unbound) - files = rendered.split('file.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('handle @mirror_private {\n respond 404', files) - self.assertIn('handle @zig_mirror {\n respond 503', files) - services['zig-mirror'] = (5555, ['caddy-host=zig.paperclover.net']) - enabled = router.render('fixture') - files = enabled.split('file.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('reverse_proxy 127.0.0.1:5555', files) - (stages / (jellyfin + '.json')).unlink() - rendered = router.render('fixture') - preview = rendered.split(jellyfin + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] - self.assertIn('respond 503', preview) - self.assertNotIn('reverse_proxy', preview) - - -class JellyfinRouter(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.root = tempfile.TemporaryDirectory(prefix='snowglobe-jellyfin-router-') - cls.backend = ThreadingHTTPServer(('127.0.0.1', 0), Backend) - cls.gateway = ThreadingHTTPServer(('127.0.0.1', 0), Gateway) - for server in (cls.backend, cls.gateway): - threading.Thread(target=server.serve_forever, daemon=True).start() - with socket.socket() as listener: - listener.bind(('127.0.0.1', 0)) - cls.port = listener.getsockname()[1] - conf = Path(cls.root.name) / 'Caddyfile' - route = '\n'.join(router.jellyfin_routes('jellyfin-preview-1234abcd', {f'127.0.0.1:{cls.backend.server_port}'}, f'127.0.0.1:{cls.gateway.server_port}', 'a' * 64)) - conf.write_text('{\n admin off\n auto_https off\n}\nhttp://127.0.0.1:' + str(cls.port) + ' {\n' + route + '\n}\n') - validated = subprocess.run([str(CADDY), 'validate', '--config', str(conf), '--adapter', 'caddyfile'], capture_output=True, text=True) - if validated.returncode: - raise RuntimeError(validated.stderr) - - cls.log = (Path(cls.root.name) / 'caddy.log').open('w+') - cls.caddy = subprocess.Popen([str(CADDY), 'run', '--config', str(conf), '--adapter', 'caddyfile'], stdout=cls.log, stderr=cls.log) - deadline = time.monotonic() + 10 - while True: - try: - cls.request('GET', '/ready') - break - except OSError: - if time.monotonic() > deadline or cls.caddy.poll() is not None: - cls.log.seek(0) - raise RuntimeError(cls.log.read()) - time.sleep(.05) - - @classmethod - def tearDownClass(cls): - cls.caddy.terminate() - cls.caddy.wait(timeout=10) - cls.backend.shutdown() - cls.gateway.shutdown() - cls.backend.server_close() - cls.gateway.server_close() - cls.log.close() - cls.root.cleanup() - - @classmethod - def request(cls, method, path, body=None, headers=None): - connection = HTTPConnection('127.0.0.1', cls.port, timeout=3) - connection.request(method, path, body=body, headers=headers or {}) - response = connection.getresponse() - result = response.status, dict(response.getheaders()), response.read() - connection.close() - return result - - def setUp(self): - Backend.requests.clear() - Gateway.requests.clear() - - def test_default_deny_includes_theme_assets_and_fallback(self): - for path in ['/web/', '/web/extra/cloverfin.css', '/favicon.ico', '/Items/known', '/Videos/x/stream', '/socket']: - with self.subTest(path=path): - self.assertEqual(self.request('GET', path, headers={'Snowglobe-Proxy-Token': 'forged', 'Snowglobe-Jellyfin-Service': 'jellyfin'})[0], 401) - self.assertEqual(Backend.requests, []) - self.assertTrue(all(r[2]['Snowglobe-Jellyfin-Service'] == 'jellyfin-preview-1234abcd' for r in Gateway.requests)) - count = len(Gateway.requests) - for path in ['/Snowglobe/Bridge', '/sNoWgLoBe/Bridge', '/metrics', '/Users/AuthenticateByName', '/Users/' + '1' * 32 + '/Authenticate', '/Users/ForgotPassword/Pin', '/QuickConnect/Authorize']: - self.assertEqual(self.request('POST', path, body='{}', headers={'Authorization': 'allow'})[0], 404) - self.assertEqual(len(Gateway.requests), count) - self.assertEqual(Backend.requests, []) - - def test_public_protocol_preserves_method_body_and_uri(self): - body = '{"DeviceId":"fixture"}' - status, _, payload = self.request('POST', '/QuickConnect/Initiate?fixture=1', body=body) - self.assertEqual(status, 200) - self.assertEqual(json.loads(payload), {'method': 'POST', 'body': body}) - self.assertEqual(Gateway.requests[-1][2]['Snowglobe-Jellyfin-Uri'], '/QuickConnect/Initiate?fixture=1') - self.assertEqual(Backend.requests, []) - self.assertEqual(self.request('GET', '/QuickConnect/Initiate')[0], 401) - - def test_legacy_public_route_case_keeps_exact_method_and_path_boundary(self): - for path in ['/users/public', '/branding/configuration', '/qUiCkCoNnEcT/eNaBlEd']: - self.assertEqual(self.request('GET', path)[0], 200) - self.assertEqual(Gateway.requests[-1][1], '/auth/jellyfin/public') - self.assertEqual(self.request('POST', '/quickconnect/initiate', body='{}')[0], 200) - for path in ['/users/public/extra', '/quickconnect/initiate/extra', '/users/private', '/items/known']: - self.assertEqual(self.request('GET', path)[0], 401) - self.assertEqual(self.request('POST', '/users/public', body='{}')[0], 401) - self.assertEqual(self.request('POST', '/qUiCkCoNnEcT/aUtHoRiZe', body='{}')[0], 404) - self.assertEqual(Backend.requests, []) - - def test_authenticated_ranges_head_websocket_and_normalized_credential(self): - headers = {'Authorization': 'allow', 'Cookie': 'private=never-upstream', 'X-Emby-Token': 'legacy', 'Snowglobe-Jellyfin-Upstream': 'attacker'} - status, response_headers, body = self.request('GET', '/Videos/fixture/stream?ApiKey=old&api_key=old&aPiKeY=old&static=true', headers={**headers, 'Range': 'bytes=0-4'}) - self.assertEqual((status, body), (206, b'hello')) - self.assertEqual(response_headers['Content-Range'], 'bytes 0-4/10') - self.assertEqual({k.lower(): v for k, v in response_headers.items()}['etag'], '"fixture"') - self.assertIn('HttpOnly', response_headers['Set-Cookie']) - method, path, upstream = Backend.requests[-1] - self.assertEqual((method, path), ('GET', '/Videos/fixture/stream?static=true')) - self.assertEqual(upstream['Authorization'], 'MediaBrowser Token="normalized"') - self.assertFalse(any(k.lower().startswith(('snowglobe-', 'x-snowglobe-')) or k.lower() in {'cookie', 'x-emby-token'} for k in upstream)) - for path, expected in [ - ('/Videos/fixture/stream?ApiKey=old', '/Videos/fixture/stream'), - ('/Videos/fixture/stream?api_key=old&static=true&signature=abc%3D%3D&name=a%26b', '/Videos/fixture/stream?static=true&signature=abc%3D%3D&name=a%26b'), - ]: - self.assertEqual(self.request('GET', path, headers=headers)[0], 200) - self.assertEqual(Backend.requests[-1][1], expected) - status, _, body = self.request('HEAD', '/Videos/fixture/stream', headers=headers) - self.assertEqual((status, body), (200, b'')) - self.assertEqual(Backend.requests[-1][0], 'HEAD') - self.assertEqual(self.request('POST', '/Items/fixture/PlaybackInfo', body='synthetic playback options', headers=headers)[0], 200) - self.assertEqual(Backend.requests[-1][0], 'POST') - self.assertEqual(Backend.bodies[-1], b'synthetic playback options') - self.assertEqual(self.request('GET', '/socket', headers={**headers, 'Connection': 'Upgrade', 'Upgrade': 'websocket'})[0], 101) - self.assertEqual(Backend.requests[-1][2]['Upgrade'], 'websocket') - - def test_narrow_artwork_still_passes_gateway_check(self): - self.assertEqual(self.request('GET', '/Items/' + '1' * 32 + '/Images/Primary?maxWidth=300')[0], 200) - self.assertEqual(Gateway.requests[-1][1], '/auth/jellyfin/check') - self.assertEqual(len(Backend.requests), 1) - - def test_z_upstream_failure_does_not_log_native_credentials(self): - self.gateway.shutdown() - self.gateway.server_close() - secret = 'SYNTHETIC-PAIRING-SECRET' - self.assertEqual(self.request('GET', '/QuickConnect/Connect?secret=' + secret, - headers={'X-Emby-Token': 'SYNTHETIC-NATIVE-TOKEN'})[0], 503) - self.log.flush() - self.log.seek(0) - log = self.log.read() - self.assertNotIn(secret, log) - self.assertNotIn('SYNTHETIC-NATIVE-TOKEN', log) - - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - parser.add_argument('--caddy', type=Path, required=True) - args, remaining = parser.parse_known_args() - CADDY = args.caddy - unittest.main(argv=[__file__, *remaining]) diff --git a/tools/router-shale-gateway-test.py b/tools/router-shale-gateway-test.py new file mode 100644 index 0000000000000000000000000000000000000000..c392ad83d6ca50e0708fbd7c0417a9c0cd9011a1 --- /dev/null +++ b/tools/router-shale-gateway-test.py @@ -0,0 +1,65 @@ +import json +import os +from pathlib import Path +import tempfile +import unittest +from unittest.mock import patch + +import router + + +class GatewayAssociation(unittest.TestCase): + def test_preview_uses_its_own_gateway(self): + with tempfile.TemporaryDirectory(prefix='shale-gateway-') as temporary: + root = Path(temporary) + stages = root / 'stages' + stages.mkdir() + shale = 'shale-preview-5678abcd' + dashboard = 'dashboard-preview-1234abcd' + (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale', 'gatewayStage': dashboard})) + mount = root / 'staging' / dashboard + mount.mkdir(parents=True) + proxy_proof = mount / 'proxy.token' + proxy_proof.write_text('b' * 64) + proxy_proof.chmod(0o400) + (stages / (dashboard + '.json')).write_text(json.dumps({'sourceId': 'dashboard', 'mount': str(mount)})) + proof = root / 'proof' + proof.write_text('a' * 64) + services = { + shale: (6666, ['caddy-host=' + shale + '.paperclover.net']), + dashboard: (3333, ['caddy-host=' + dashboard + '.paperclover.net']), + } + + def nomad(path, _): + if path == '/v1/services': + return [{'Namespace': 'default', 'Services': [{'ServiceName': name} for name in services]}] + if path.startswith('/v1/service/'): + name = path.rsplit('/', 1)[1] + port, tags = services[name] + return [{'ServiceName': name, 'JobID': name, 'AllocID': name, 'Address': '127.0.0.1', 'Port': port, 'Tags': tags}] + return {'http': {'Status': 'success'}} + + environment = {'SNOWGLOBE_DOMAIN': 'paperclover.net', 'SNOWGLOBE_DASHBOARD_PORT': '4444', + 'SNOWGLOBE_PROXY_TOKEN_FILE': str(proof), 'SNOWGLOBE_STATE': temporary} + with patch.dict(os.environ, environment, clear=True), patch.object(router, 'nomad', nomad), patch.object(router, 'ROUTE_DIR', str(root / 'routes')): + rendered = router.render('fixture') + dashboard_route = rendered.split(dashboard + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] + self.assertIn('request_header Snowglobe-Proxy-Token ' + 'b' * 64, dashboard_route) + shale_route = rendered.split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] + self.assertIn('reverse_proxy 127.0.0.1:3333', shale_route) + self.assertIn('Snowglobe-Shale-Upstream "127.0.0.1:6666"', shale_route) + self.assertIn('b' * 64, shale_route) + self.assertNotIn('a' * 64, shale_route) + self.assertNotIn('reverse_proxy 127.0.0.1:4444', shale_route) + (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'wrong', 'gatewayStage': dashboard})) + denied = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] + self.assertIn('respond 503', denied) + self.assertNotIn('/auth/shale/page', denied) + (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale'})) + unbound = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] + self.assertIn('reverse_proxy 127.0.0.1:4444', unbound) + self.assertIn('a' * 64, unbound) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/router.py b/tools/router.py index a77f740824e3eee31d28289885c9840763c45ec5..4b7e6ff6930258276794df8e542ab3e9bbf13672 100644 --- a/tools/router.py +++ b/tools/router.py @@ -163,9 +163,9 @@ def dashboard_preview_proof(service): return proof -def service_gateway(service, routes, proof): +def shale_gateway(service, routes, proof): source = service.split("-preview-", 1)[0] - if source not in {"jellyfin", "shale"}: + if source != "shale": return None, None stages = os.path.join(os.environ.get("SNOWGLOBE_STATE", "/var/lib/snowglobe"), "stages") gateway = None @@ -178,8 +178,6 @@ def service_gateway(service, routes, proof): if stage.get("sourceId") != source: return None, None gateway = stage.get("gatewayStage") - if gateway is None and source != "shale": - return None, None if gateway is not None and (not isinstance(gateway, str) or not re.fullmatch(r"dashboard-preview-[0-9a-f]{8}", gateway)): return None, None if gateway is None: @@ -203,47 +201,6 @@ def service_gateway(service, routes, proof): return (upstream, proof) if proof else (None, None) -def jellyfin_routes(service, upstreams, gateway, proof): - if len(upstreams) != 1 or not re.fullmatch(r"127\.0\.0\.1:[0-9]+|\[::1\]:[0-9]+", next(iter(upstreams))): - raise ValueError("Jellyfin requires one private loopback upstream") - upstream = next(iter(upstreams)) - trusted = [f" header_up Snowglobe-Proxy-Token {proof}" if proof else " header_up -Snowglobe-Proxy-Token", - f" header_up Snowglobe-Jellyfin-Service {service}", - f" header_up Snowglobe-Jellyfin-Upstream {upstream}", - " header_up Snowglobe-Jellyfin-Uri {http.vars.jellyfin_uri}", - " header_up Snowglobe-Jellyfin-Method {http.vars.jellyfin_method}", - " header_up X-Snowglobe-Client-IP {remote_host}"] - lines = [" route {", " vars jellyfin_uri {uri}", " vars jellyfin_method {method}", - " request_header -Snowglobe-Jellyfin-*", " request_header -Snowglobe-Proxy-Token", - " request_header -X-Snowglobe-Jellyfin-*", " request_header -User-Name", " request_header -User-Groups", - " @jellyfin_private path_regexp jellyfin_private (?i)^/(?:snowglobe(?:/|$)|metrics(?:/|$)|users/(?:authenticatebyname|[0-9a-f-]+/authenticate|forgotpassword(?:/pin)?)(?:/|$)|quickconnect/authorize(?:/|$))", - " respond @jellyfin_private 404"] - paths = { - "GET": "/System/Info/Public /System/Ping /Users/Public /Branding/Configuration /QuickConnect/Enabled /QuickConnect/Connect /auth/jellyfin/start /auth/jellyfin/callback", - "POST": "/System/Ping /QuickConnect/Initiate /Users/AuthenticateWithQuickConnect /auth/jellyfin/session /auth/jellyfin/logout", - } - for method, allowed in paths.items(): - name = "@jellyfin_public_" + method.lower() - pattern = "(?i)^(?:" + "|".join(re.escape(path) for path in allowed.split()) + ")$" - lines += [f" {name} {{", f" method {method}", f" path_regexp {name[1:]} {pattern}", " }", - f" handle {name} {{", f" reverse_proxy {gateway} {{", " rewrite /auth/jellyfin/public?", - *[" " + line for line in trusted], " }", " }"] - lines += [" @jellyfin_options method OPTIONS", " handle @jellyfin_options {", - f" reverse_proxy {gateway} {{", " rewrite /auth/jellyfin/public?", - *[" " + line for line in trusted], " }", " }", " handle {", - f" reverse_proxy {gateway} {{", " method GET", " rewrite /auth/jellyfin/check?", - *[" " + line for line in trusted], " @jellyfin_allowed status 204", " handle_response @jellyfin_allowed {", - " header +Set-Cookie {rp.header.Set-Cookie}", - " request_header -X-Emby-Token", " request_header -X-MediaBrowser-Token", - " request_header -X-Emby-Authorization", " request_header -Cookie", - " request_header Authorization {rp.header.X-Snowglobe-Jellyfin-Authorization}", - # Caddy needs a literal query delimiter to replace a query from a response header. - " rewrite * {rp.header.X-Snowglobe-Jellyfin-Uri}?", f" reverse_proxy {upstream} {{", - " header_up -Snowglobe-*", " header_up -X-Snowglobe-*", " }", - " }", " }", " }", " }", " handle_errors {", " respond 503", " }"] - return lines - - def render(token): with open(os.environ["SNOWGLOBE_PROXY_TOKEN_FILE"]) as file: dashboard_proof = file.read().strip() @@ -297,11 +254,7 @@ def render(token): user_header = user_headers[0] if user_headers and role else None if not HOST.fullmatch(host): raise ValueError(f"invalid Caddy host: {host!r}") - route = routes.setdefault((80, host), {"upstreams": set(), "services": set(), "authRole": None, "userHeader": None, "internal": False, "realIp": False, "secureCookies": False, "jellyfinAuth": False}) - if "caddy-jellyfin-auth=true" in tags: - if not (instance["ServiceName"] == "jellyfin" or re.fullmatch(r"jellyfin-preview-[0-9a-f]{8}", instance["ServiceName"])): - raise ValueError("Jellyfin gateway tag belongs to another service") - route["jellyfinAuth"] = True + route = routes.setdefault((80, host), {"upstreams": set(), "services": set(), "authRole": None, "userHeader": None, "internal": False, "realIp": False, "secureCookies": False}) if role and route["authRole"] not in (None, role): raise ValueError("conflicting route access roles") if user_header and route["userHeader"] not in (None, user_header): @@ -366,14 +319,6 @@ def render(token): if not 1 <= port <= 65535: raise ValueError("invalid dashboard port for Shale linking") lines += shale_mcp_routes(port) - if route["jellyfinAuth"]: - gateway, proof = service_gateway(service, routes, dashboard_proof) - if gateway: - lines += jellyfin_routes(service, route["upstreams"], gateway, proof) - else: - lines.append(" respond 503") - lines.append("}") - continue lines += [" tracing {", f" span {service}", " span_attributes {", f" snowglobe.service {service}", " snowglobe.kind edge", " }", " }"] if service == "copyparty" or re.fullmatch(r"copyparty-preview-[0-9a-f]{8}", service): @@ -475,7 +420,7 @@ def render(token): shale_page = service == "shale" or re.fullmatch(r"shale-preview-[0-9a-f]{8}", service) page_headers = [] if shale_page: - page_upstream, proof = service_gateway(service, routes, dashboard_proof) + page_upstream, proof = shale_gateway(service, routes, dashboard_proof) if not page_upstream: lines += [" respond 503", " }", "}"] continue diff --git a/tools/snowglobe.py b/tools/snowglobe.py index 2a7e21e1d1f8a0acae7239cc17ed956e9198bbc4..0085ec2eb706b5e60ec598c9f11e5da7b3abb9b5 100644 --- a/tools/snowglobe.py +++ b/tools/snowglobe.py @@ -349,8 +349,6 @@ def render(data, definitions): tags.append("caddy-user-header=" + endpoint["userHeader"]) if endpoint["forwardRealIp"]: tags.append("caddy-real-ip=true") - if endpoint.get("jellyfinAuth"): - tags.append("caddy-jellyfin-auth=true") if endpoint.get("secureCookies"): tags.append("caddy-secure-cookies=true") if endpoint["tlsInternal"]: