| ... | ... | @@ -1,300 +0,0 @@ |
| 1 | | #!/usr/bin/env python3 |
| 2 | | import argparse |
| 3 | | from http.client import HTTPConnection |
| 4 | | from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| 5 | | import json |
| 6 | | import os |
| 7 | | import socket |
| 8 | | import subprocess |
| 9 | | import tempfile |
| 10 | | import threading |
| 11 | | import time |
| 12 | | from pathlib import Path |
| 13 | | import unittest |
| 14 | | import urllib.parse |
| 15 | | from unittest.mock import patch |
| 16 | | |
| 17 | | import router |
| 18 | | |
| 19 | | |
| 20 | | class Backend(BaseHTTPRequestHandler): |
| 21 | | requests = [] |
| 22 | | bodies = [] |
| 23 | | |
| 24 | | def do_GET(self): |
| 25 | | type(self).requests.append((self.command, self.path, dict(self.headers))) |
| 26 | | type(self).bodies.append(self.rfile.read(int(self.headers.get('Content-Length', '0')))) |
| 27 | | if self.headers.get('Upgrade', '').lower() == 'websocket': |
| 28 | | self.send_response(101) |
| 29 | | self.send_header('Connection', 'Upgrade') |
| 30 | | self.send_header('Upgrade', 'websocket') |
| 31 | | self.end_headers() |
| 32 | | return |
| 33 | | self.send_response(206 if self.headers.get('Range') else 200) |
| 34 | | self.send_header('Content-Type', 'application/octet-stream') |
| 35 | | self.send_header('ETag', '"fixture"') |
| 36 | | self.send_header('Content-Length', '5') |
| 37 | | if self.headers.get('Range'): |
| 38 | | self.send_header('Content-Range', 'bytes 0-4/10') |
| 39 | | self.end_headers() |
| 40 | | if self.command != 'HEAD': |
| 41 | | self.wfile.write(b'hello') |
| 42 | | |
| 43 | | do_HEAD = do_GET |
| 44 | | do_POST = do_GET |
| 45 | | |
| 46 | | def log_message(self, *_): |
| 47 | | pass |
| 48 | | |
| 49 | | |
| 50 | | class Gateway(BaseHTTPRequestHandler): |
| 51 | | requests = [] |
| 52 | | |
| 53 | | def do_GET(self): |
| 54 | | size = int(self.headers.get('Content-Length', '0')) |
| 55 | | body = self.rfile.read(size) |
| 56 | | type(self).requests.append((self.command, self.path, dict(self.headers), body)) |
| 57 | | trusted = self.headers.get('Snowglobe-Proxy-Token') == 'a' * 64 |
| 58 | | original = self.headers.get('Snowglobe-Jellyfin-Uri', '') |
| 59 | | if not trusted: |
| 60 | | self.send_error(403) |
| 61 | | elif self.path == '/auth/jellyfin/public': |
| 62 | | self.send_response(200) |
| 63 | | self.send_header('Content-Type', 'application/json') |
| 64 | | self.end_headers() |
| 65 | | self.wfile.write(json.dumps({'method': self.headers.get('Snowglobe-Jellyfin-Method'), 'body': body.decode()}).encode()) |
| 66 | | elif self.headers.get('Authorization') == 'allow' or original.startswith('/Items/' + '1' * 32 + '/Images/Primary'): |
| 67 | | self.send_response(204) |
| 68 | | path, _, query = original.partition('?') |
| 69 | | kept = [part for part in query.split('&') if part and urllib.parse.unquote_plus(part.split('=', 1)[0]).lower() not in {'apikey', 'api_key'}] |
| 70 | | self.send_header('X-Snowglobe-Jellyfin-Uri', path + ('?' + '&'.join(kept) if kept else '')) |
| 71 | | if self.headers.get('Authorization'): |
| 72 | | self.send_header('X-Snowglobe-Jellyfin-Authorization', 'MediaBrowser Token="normalized"') |
| 73 | | self.send_header('Set-Cookie', '__Host-snow-jellyfin=normalized; HttpOnly; Secure; Path=/') |
| 74 | | self.end_headers() |
| 75 | | else: |
| 76 | | self.send_error(401) |
| 77 | | |
| 78 | | do_POST = do_GET |
| 79 | | do_OPTIONS = do_GET |
| 80 | | |
| 81 | | def log_message(self, *_): |
| 82 | | pass |
| 83 | | |
| 84 | | |
| 85 | | class GatewayAssociation(unittest.TestCase): |
| 86 | | def test_only_tagged_preview_uses_its_own_gateway(self): |
| 87 | | with tempfile.TemporaryDirectory(prefix='jellyfin-gateway-') as temporary: |
| 88 | | root = Path(temporary) |
| 89 | | stages = root / 'stages' |
| 90 | | stages.mkdir() |
| 91 | | jellyfin = 'jellyfin-preview-1234abcd' |
| 92 | | shale = 'shale-preview-5678abcd' |
| 93 | | dashboard = 'dashboard-preview-1234abcd' |
| 94 | | (stages / (jellyfin + '.json')).write_text(json.dumps({'sourceId': 'jellyfin', 'gatewayStage': dashboard})) |
| 95 | | (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale', 'gatewayStage': dashboard})) |
| 96 | | mount = root / 'staging' / dashboard |
| 97 | | mount.mkdir(parents=True) |
| 98 | | proxy_proof = mount / 'proxy.token' |
| 99 | | proxy_proof.write_text('b' * 64) |
| 100 | | proxy_proof.chmod(0o400) |
| 101 | | (stages / (dashboard + '.json')).write_text(json.dumps({'sourceId': 'dashboard', 'mount': str(mount)})) |
| 102 | | proof = root / 'proof' |
| 103 | | proof.write_text('a' * 64) |
| 104 | | services = { |
| 105 | | 'jellyfin': (1111, ['caddy-host=jelly.paperclover.net']), |
| 106 | | 'copyparty': (1112, ['caddy-host=file.paperclover.net']), |
| 107 | | jellyfin: (2222, ['caddy-host=' + jellyfin + '.paperclover.net', 'caddy-jellyfin-auth=true']), |
| 108 | | shale: (6666, ['caddy-host=' + shale + '.paperclover.net']), |
| 109 | | dashboard: (3333, ['caddy-host=' + dashboard + '.paperclover.net']), |
| 110 | | } |
| 111 | | |
| 112 | | def nomad(path, _): |
| 113 | | if path == '/v1/services': |
| 114 | | return [{'Namespace': 'default', 'Services': [{'ServiceName': name} for name in services]}] |
| 115 | | if path.startswith('/v1/service/'): |
| 116 | | name = path.rsplit('/', 1)[1] |
| 117 | | port, tags = services[name] |
| 118 | | return [{'ServiceName': name, 'JobID': name, 'AllocID': name, 'Address': '127.0.0.1', 'Port': port, 'Tags': tags}] |
| 119 | | return {'http': {'Status': 'success'}} |
| 120 | | |
| 121 | | environment = {'SNOWGLOBE_DOMAIN': 'paperclover.net', 'SNOWGLOBE_DASHBOARD_PORT': '4444', |
| 122 | | 'SNOWGLOBE_PROXY_TOKEN_FILE': str(proof), 'SNOWGLOBE_STATE': temporary} |
| 123 | | with patch.dict(os.environ, environment, clear=True), patch.object(router, 'nomad', nomad), patch.object(router, 'ROUTE_DIR', str(root / 'routes')): |
| 124 | | rendered = router.render('fixture') |
| 125 | | legacy = rendered.split('jelly.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 126 | | preview = rendered.split(jellyfin + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 127 | | self.assertNotIn('/auth/jellyfin/', legacy) |
| 128 | | self.assertIn('reverse_proxy 127.0.0.1:1111', legacy) |
| 129 | | self.assertIn('reverse_proxy 127.0.0.1:3333', preview) |
| 130 | | self.assertNotIn('reverse_proxy 127.0.0.1:4444', preview) |
| 131 | | self.assertNotIn('a' * 64, preview) |
| 132 | | self.assertIn('b' * 64, preview) |
| 133 | | dashboard_route = rendered.split(dashboard + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 134 | | self.assertIn('request_header Snowglobe-Proxy-Token ' + 'b' * 64, dashboard_route) |
| 135 | | self.assertNotIn('tracing', preview) |
| 136 | | shale_route = rendered.split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 137 | | self.assertIn('reverse_proxy 127.0.0.1:3333', shale_route) |
| 138 | | self.assertIn('Snowglobe-Shale-Upstream "127.0.0.1:6666"', shale_route) |
| 139 | | self.assertIn('b' * 64, shale_route) |
| 140 | | self.assertNotIn('a' * 64, shale_route) |
| 141 | | self.assertNotIn('reverse_proxy 127.0.0.1:4444', shale_route) |
| 142 | | (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'jellyfin', 'gatewayStage': dashboard})) |
| 143 | | denied = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 144 | | self.assertIn('respond 503', denied) |
| 145 | | self.assertNotIn('/auth/shale/page', denied) |
| 146 | | (stages / (shale + '.json')).write_text(json.dumps({'sourceId': 'shale'})) |
| 147 | | unbound = router.render('fixture').split(shale + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 148 | | self.assertIn('reverse_proxy 127.0.0.1:4444', unbound) |
| 149 | | self.assertIn('a' * 64, unbound) |
| 150 | | files = rendered.split('file.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 151 | | self.assertIn('handle @mirror_private {\n respond 404', files) |
| 152 | | self.assertIn('handle @zig_mirror {\n respond 503', files) |
| 153 | | services['zig-mirror'] = (5555, ['caddy-host=zig.paperclover.net']) |
| 154 | | enabled = router.render('fixture') |
| 155 | | files = enabled.split('file.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 156 | | self.assertIn('reverse_proxy 127.0.0.1:5555', files) |
| 157 | | (stages / (jellyfin + '.json')).unlink() |
| 158 | | rendered = router.render('fixture') |
| 159 | | preview = rendered.split(jellyfin + '.paperclover.net {', 1)[1].split('\n}\n', 1)[0] |
| 160 | | self.assertIn('respond 503', preview) |
| 161 | | self.assertNotIn('reverse_proxy', preview) |
| 162 | | |
| 163 | | |
| 164 | | class JellyfinRouter(unittest.TestCase): |
| 165 | | @classmethod |
| 166 | | def setUpClass(cls): |
| 167 | | cls.root = tempfile.TemporaryDirectory(prefix='snowglobe-jellyfin-router-') |
| 168 | | cls.backend = ThreadingHTTPServer(('127.0.0.1', 0), Backend) |
| 169 | | cls.gateway = ThreadingHTTPServer(('127.0.0.1', 0), Gateway) |
| 170 | | for server in (cls.backend, cls.gateway): |
| 171 | | threading.Thread(target=server.serve_forever, daemon=True).start() |
| 172 | | with socket.socket() as listener: |
| 173 | | listener.bind(('127.0.0.1', 0)) |
| 174 | | cls.port = listener.getsockname()[1] |
| 175 | | conf = Path(cls.root.name) / 'Caddyfile' |
| 176 | | 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)) |
| 177 | | conf.write_text('{\n admin off\n auto_https off\n}\nhttp://127.0.0.1:' + str(cls.port) + ' {\n' + route + '\n}\n') |
| 178 | | validated = subprocess.run([str(CADDY), 'validate', '--config', str(conf), '--adapter', 'caddyfile'], capture_output=True, text=True) |
| 179 | | if validated.returncode: |
| 180 | | raise RuntimeError(validated.stderr) |
| 181 | | |
| 182 | | cls.log = (Path(cls.root.name) / 'caddy.log').open('w+') |
| 183 | | cls.caddy = subprocess.Popen([str(CADDY), 'run', '--config', str(conf), '--adapter', 'caddyfile'], stdout=cls.log, stderr=cls.log) |
| 184 | | deadline = time.monotonic() + 10 |
| 185 | | while True: |
| 186 | | try: |
| 187 | | cls.request('GET', '/ready') |
| 188 | | break |
| 189 | | except OSError: |
| 190 | | if time.monotonic() > deadline or cls.caddy.poll() is not None: |
| 191 | | cls.log.seek(0) |
| 192 | | raise RuntimeError(cls.log.read()) |
| 193 | | time.sleep(.05) |
| 194 | | |
| 195 | | @classmethod |
| 196 | | def tearDownClass(cls): |
| 197 | | cls.caddy.terminate() |
| 198 | | cls.caddy.wait(timeout=10) |
| 199 | | cls.backend.shutdown() |
| 200 | | cls.gateway.shutdown() |
| 201 | | cls.backend.server_close() |
| 202 | | cls.gateway.server_close() |
| 203 | | cls.log.close() |
| 204 | | cls.root.cleanup() |
| 205 | | |
| 206 | | @classmethod |
| 207 | | def request(cls, method, path, body=None, headers=None): |
| 208 | | connection = HTTPConnection('127.0.0.1', cls.port, timeout=3) |
| 209 | | connection.request(method, path, body=body, headers=headers or {}) |
| 210 | | response = connection.getresponse() |
| 211 | | result = response.status, dict(response.getheaders()), response.read() |
| 212 | | connection.close() |
| 213 | | return result |
| 214 | | |
| 215 | | def setUp(self): |
| 216 | | Backend.requests.clear() |
| 217 | | Gateway.requests.clear() |
| 218 | | |
| 219 | | def test_default_deny_includes_theme_assets_and_fallback(self): |
| 220 | | for path in ['/web/', '/web/extra/cloverfin.css', '/favicon.ico', '/Items/known', '/Videos/x/stream', '/socket']: |
| 221 | | with self.subTest(path=path): |
| 222 | | self.assertEqual(self.request('GET', path, headers={'Snowglobe-Proxy-Token': 'forged', 'Snowglobe-Jellyfin-Service': 'jellyfin'})[0], 401) |
| 223 | | self.assertEqual(Backend.requests, []) |
| 224 | | self.assertTrue(all(r[2]['Snowglobe-Jellyfin-Service'] == 'jellyfin-preview-1234abcd' for r in Gateway.requests)) |
| 225 | | count = len(Gateway.requests) |
| 226 | | for path in ['/Snowglobe/Bridge', '/sNoWgLoBe/Bridge', '/metrics', '/Users/AuthenticateByName', '/Users/' + '1' * 32 + '/Authenticate', '/Users/ForgotPassword/Pin', '/QuickConnect/Authorize']: |
| 227 | | self.assertEqual(self.request('POST', path, body='{}', headers={'Authorization': 'allow'})[0], 404) |
| 228 | | self.assertEqual(len(Gateway.requests), count) |
| 229 | | self.assertEqual(Backend.requests, []) |
| 230 | | |
| 231 | | def test_public_protocol_preserves_method_body_and_uri(self): |
| 232 | | body = '{"DeviceId":"fixture"}' |
| 233 | | status, _, payload = self.request('POST', '/QuickConnect/Initiate?fixture=1', body=body) |
| 234 | | self.assertEqual(status, 200) |
| 235 | | self.assertEqual(json.loads(payload), {'method': 'POST', 'body': body}) |
| 236 | | self.assertEqual(Gateway.requests[-1][2]['Snowglobe-Jellyfin-Uri'], '/QuickConnect/Initiate?fixture=1') |
| 237 | | self.assertEqual(Backend.requests, []) |
| 238 | | self.assertEqual(self.request('GET', '/QuickConnect/Initiate')[0], 401) |
| 239 | | |
| 240 | | def test_legacy_public_route_case_keeps_exact_method_and_path_boundary(self): |
| 241 | | for path in ['/users/public', '/branding/configuration', '/qUiCkCoNnEcT/eNaBlEd']: |
| 242 | | self.assertEqual(self.request('GET', path)[0], 200) |
| 243 | | self.assertEqual(Gateway.requests[-1][1], '/auth/jellyfin/public') |
| 244 | | self.assertEqual(self.request('POST', '/quickconnect/initiate', body='{}')[0], 200) |
| 245 | | for path in ['/users/public/extra', '/quickconnect/initiate/extra', '/users/private', '/items/known']: |
| 246 | | self.assertEqual(self.request('GET', path)[0], 401) |
| 247 | | self.assertEqual(self.request('POST', '/users/public', body='{}')[0], 401) |
| 248 | | self.assertEqual(self.request('POST', '/qUiCkCoNnEcT/aUtHoRiZe', body='{}')[0], 404) |
| 249 | | self.assertEqual(Backend.requests, []) |
| 250 | | |
| 251 | | def test_authenticated_ranges_head_websocket_and_normalized_credential(self): |
| 252 | | headers = {'Authorization': 'allow', 'Cookie': 'private=never-upstream', 'X-Emby-Token': 'legacy', 'Snowglobe-Jellyfin-Upstream': 'attacker'} |
| 253 | | 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'}) |
| 254 | | self.assertEqual((status, body), (206, b'hello')) |
| 255 | | self.assertEqual(response_headers['Content-Range'], 'bytes 0-4/10') |
| 256 | | self.assertEqual({k.lower(): v for k, v in response_headers.items()}['etag'], '"fixture"') |
| 257 | | self.assertIn('HttpOnly', response_headers['Set-Cookie']) |
| 258 | | method, path, upstream = Backend.requests[-1] |
| 259 | | self.assertEqual((method, path), ('GET', '/Videos/fixture/stream?static=true')) |
| 260 | | self.assertEqual(upstream['Authorization'], 'MediaBrowser Token="normalized"') |
| 261 | | self.assertFalse(any(k.lower().startswith(('snowglobe-', 'x-snowglobe-')) or k.lower() in {'cookie', 'x-emby-token'} for k in upstream)) |
| 262 | | for path, expected in [ |
| 263 | | ('/Videos/fixture/stream?ApiKey=old', '/Videos/fixture/stream'), |
| 264 | | ('/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'), |
| 265 | | ]: |
| 266 | | self.assertEqual(self.request('GET', path, headers=headers)[0], 200) |
| 267 | | self.assertEqual(Backend.requests[-1][1], expected) |
| 268 | | status, _, body = self.request('HEAD', '/Videos/fixture/stream', headers=headers) |
| 269 | | self.assertEqual((status, body), (200, b'')) |
| 270 | | self.assertEqual(Backend.requests[-1][0], 'HEAD') |
| 271 | | self.assertEqual(self.request('POST', '/Items/fixture/PlaybackInfo', body='synthetic playback options', headers=headers)[0], 200) |
| 272 | | self.assertEqual(Backend.requests[-1][0], 'POST') |
| 273 | | self.assertEqual(Backend.bodies[-1], b'synthetic playback options') |
| 274 | | self.assertEqual(self.request('GET', '/socket', headers={**headers, 'Connection': 'Upgrade', 'Upgrade': 'websocket'})[0], 101) |
| 275 | | self.assertEqual(Backend.requests[-1][2]['Upgrade'], 'websocket') |
| 276 | | |
| 277 | | def test_narrow_artwork_still_passes_gateway_check(self): |
| 278 | | self.assertEqual(self.request('GET', '/Items/' + '1' * 32 + '/Images/Primary?maxWidth=300')[0], 200) |
| 279 | | self.assertEqual(Gateway.requests[-1][1], '/auth/jellyfin/check') |
| 280 | | self.assertEqual(len(Backend.requests), 1) |
| 281 | | |
| 282 | | def test_z_upstream_failure_does_not_log_native_credentials(self): |
| 283 | | self.gateway.shutdown() |
| 284 | | self.gateway.server_close() |
| 285 | | secret = 'SYNTHETIC-PAIRING-SECRET' |
| 286 | | self.assertEqual(self.request('GET', '/QuickConnect/Connect?secret=' + secret, |
| 287 | | headers={'X-Emby-Token': 'SYNTHETIC-NATIVE-TOKEN'})[0], 503) |
| 288 | | self.log.flush() |
| 289 | | self.log.seek(0) |
| 290 | | log = self.log.read() |
| 291 | | self.assertNotIn(secret, log) |
| 292 | | self.assertNotIn('SYNTHETIC-NATIVE-TOKEN', log) |
| 293 | | |
| 294 | | |
| 295 | | if __name__ == '__main__': |
| 296 | | parser = argparse.ArgumentParser() |
| 297 | | parser.add_argument('--caddy', type=Path, required=True) |
| 298 | | args, remaining = parser.parse_known_args() |
| 299 | | CADDY = args.caddy |
| 300 | | unittest.main(argv=[__file__, *remaining]) |