Harden public proxy access, filesystem boundaries and content policy
This commit is contained in:
1 parent
219e64f5a2
commit
d5ac22777f
12 files changed
+213
-14
No files matched your search
@@ -1,5 +1,12 @@
|
||||
# Changelog
|
||||
|
||||
## 0.55.2 — 2026-10-24
|
||||
|
||||
- Enforce filesystem roots for authenticated/public installations even when the proxy connects over loopback without forwarded client headers; deny browsing without roots.
|
||||
- Restrict executable scripts to hashes of trusted page templates, including rewritten mount paths; add HSTS, frame and browser capability headers. Reject cross-site request metadata and untrusted forwarded host/protocol overrides.
|
||||
- Publish the Docker backend on loopback by default; document private proxy networking, separate subdomains and proxy rate limiting. Preserve state, downloads, queues and credentials.
|
||||
- Checked all three providers against upstream revision 04d3645b926197d0fc3cc51a6413627f6cbb0ee0; no updates were required and local patches were retained.
|
||||
|
||||
## 0.55.1 - 2026-10-22
|
||||
|
||||
- Moved Sign out to the bottom center of the left sidebar on every page, below navigation and page-specific controls. Desktop sidebars stay within the viewport and scroll when needed; mobile layouts keep the button below the sidebar content.
|
||||
|
||||
@@ -21,7 +21,7 @@ docker compose up -d --build
|
||||
|
||||
Prebuilt image: `gitea.coreplay.eu/dymas/kaizoku:latest` (also tagged by release version). The Docker image uses a separate build stage for npm dependencies to keep the runtime image smaller.
|
||||
|
||||
Open **http://127.0.0.1:8421/**. For access from another device, set `KAIZOKU_ALLOW_REMOTE=1`, `KAIZOKU_AUTH_USERNAME`, and `KAIZOKU_AUTH_PASSWORD` before starting Compose.
|
||||
Open **http://127.0.0.1:8421/**. The backend binds to host loopback by default. For access through NPM, use the private-network overlay in [SECURITY_DEPLOYMENT.md](SECURITY_DEPLOYMENT.md). For direct access from another device, explicitly set `KAIZOKU_BIND_ADDRESS` to a private interface address, restrict it with the host firewall, and set `KAIZOKU_ALLOW_REMOTE=1`, `KAIZOKU_AUTH_USERNAME`, and `KAIZOKU_AUTH_PASSWORD` before starting Compose.
|
||||
|
||||
For a local installation, install Python 3.12+, Node.js/npm, `ffmpeg`, and `openssl`, then run:
|
||||
|
||||
@@ -62,7 +62,7 @@ Open **https://tools.coreplay.eu/kaizoku/** and sign in. `/kaizoku` redirects to
|
||||
|
||||
### Troubleshooting local login and Nginx Proxy Manager
|
||||
|
||||
For a container published as `8231:8421`, use `http://SERVER_LAN_IP:8231/kaizoku/` directly and `https://tools.coreplay.eu/kaizoku/` through the proxy. Keep `KAIZOKU_BASE_URL=/kaizoku` if both addresses must work. A full HTTPS base URL fixes the expected login origin and enables Secure cookies, so direct HTTP login at a different host will not work with that setting. Credentials are case-sensitive; environment credentials override saved settings.
|
||||
For an explicitly private-interface container binding such as `192.168.1.10:8231:8421`, use `http://SERVER_LAN_IP:8231/kaizoku/` directly and `https://tools.coreplay.eu/kaizoku/` through the proxy. Keep `KAIZOKU_BASE_URL=/kaizoku` if both addresses must work. A full HTTPS base URL fixes the expected login origin and enables Secure cookies, so direct HTTP login at a different host will not work with that setting. Credentials are case-sensitive; environment credentials override saved settings.
|
||||
|
||||
When Nginx Proxy Manager connects through the Docker host, its upstream must be the host's reachable LAN address on port **8231**. When it shares a Docker network with Kaizoku, use `kaizoku` on port **8421**. Verify the hostname carefully (for example, `hade` and `hades` are different hosts). For the published host port, the location should contain one copy of each header:
|
||||
|
||||
@@ -100,3 +100,10 @@ See the **[Kaizoku wiki](https://gitea.coreplay.eu/Dymas/kaizoku/wiki)** for det
|
||||
Provider parsers are adapted from [TheYogMehta/extensions](https://github.com/TheYogMehta/extensions). Bundled versions are Anikoto **6.0.0**, AniNeko **4.0.0**, and AnimePahe **6.0.1**, checked on 2026-10-22. Anikoto retains Kaizoku search, dub detection, and stream patches; AnimePahe uses only the official `.pw`, `.com`, and `.org` mirrors with bounded search retries and bridge-compatible logging. Upstream hooks that require StrawVerse's browser or mapping database are inactive in Kaizoku.
|
||||
|
||||
Live source checks on 2026-10-17 returned Anikoto search results; AniNeko returned no matches and all three AnimePahe mirrors returned HTTP 403 from the test host. Current provider code does not guarantee source availability. Kaizoku does not host media.
|
||||
|
||||
## Security deployment
|
||||
|
||||
See [SECURITY_DEPLOYMENT.md](SECURITY_DEPLOYMENT.md) for private proxy networking,
|
||||
separate application subdomains, NPM login throttling, and the domain-root 404.
|
||||
|
||||
Public or authenticated installations enforce configured filesystem roots even for loopback proxy peers. Configure `KAIZOKU_REMOTE_PATH_ROOTS` server-side before selecting new download/library directories outside the current roots. A canonical HTTPS `KAIZOKU_BASE_URL` is recommended; direct remote clients cannot override host/protocol checks with forwarded headers. Pages authorize their bundled scripts by CSP hash; inline event-handler injection is blocked.
|
||||
@@ -0,0 +1,85 @@
|
||||
# Security deployment — 2026-10-24
|
||||
|
||||
The code hardening does not change the live VPS, DNS, certificates, Nginx Proxy
|
||||
Manager (NPM), firewall, or existing containers. These steps complete the
|
||||
infrastructure findings from the tools.coreplay.eu assessment. Existing URLs
|
||||
continue to work until you explicitly migrate them.
|
||||
|
||||
## Keep backends private
|
||||
|
||||
The default Compose host binding is loopback. A containerized NPM cannot reach
|
||||
another container through its own 127.0.0.1. On the same Docker host, create a
|
||||
private proxy network once (`docker network create coreplay-proxy`), attach NPM
|
||||
to it in its own Compose configuration, then use the supplied overlay:
|
||||
|
||||
```sh
|
||||
docker compose -f docker-compose.yaml -f deploy/compose.proxy.yaml config
|
||||
docker compose -f docker-compose.yaml -f deploy/compose.proxy.yaml up -d
|
||||
```
|
||||
|
||||
The overlay removes host port publishing and adds the proxy network while
|
||||
preserving the default network and existing volumes. It requires a current
|
||||
Docker Compose with `!reset` support. Set the NPM upstream to `kaizoku:8421`
|
||||
using HTTP and preserve the public Host header. Check the rendered Compose
|
||||
configuration before recreating containers. Never use `down -v` during upgrades.
|
||||
If NPM runs on another machine, use a private VPN/interface and a firewall rule
|
||||
allowing only that proxy, rather than publishing the port to the Internet.
|
||||
|
||||
## Separate browser origins
|
||||
|
||||
Path-scoped cookies, CSRF tokens and content policies do not isolate applications
|
||||
sharing https://tools.coreplay.eu. Create separate DNS records and NPM Proxy Hosts
|
||||
for pwatcher.coreplay.eu, cbzcleaner.coreplay.eu and kaizoku.coreplay.eu (and
|
||||
workspace.coreplay.eu when used), with valid certificates and Force SSL. For this
|
||||
application configure:
|
||||
|
||||
```dotenv
|
||||
KAIZOKU_BASE_URL=https://kaizoku.coreplay.eu
|
||||
KAIZOKU_ALLOW_REMOTE=1
|
||||
```
|
||||
|
||||
Keep the existing credentials and all persistent mounts. Remove the old mount
|
||||
path from the public URL only when the dedicated hostname is ready. Forward the
|
||||
URI without prefix stripping. Recreate the app container to apply environment
|
||||
changes, sign in again on the new origin, and remove the old proxy location after
|
||||
verifying pages, APIs, images and logout. Avoid redirects that rehost one app on
|
||||
another app's origin. Keep cookies host-only; do not set Domain=.coreplay.eu.
|
||||
For trusted HTTP development, local settings remain supported; public production
|
||||
URLs should explicitly use HTTPS.
|
||||
|
||||
## Limit authentication at NPM
|
||||
|
||||
Merge `deploy/coreplay-security-http.conf` ONCE into NPM's persistent
|
||||
`/data/nginx/custom/http_top.conf` (an http-context include). It defines a shared
|
||||
per-client login budget of five requests/minute with a burst of five for POSTs to
|
||||
the known login endpoints, including both existing and dedicated-host URLs.
|
||||
Append `deploy/npm-login-rate-limit.conf` in each affected Proxy Host's Advanced
|
||||
configuration. Ordinary polling uses an empty limiter key and is not counted.
|
||||
Application-level authentication and throttling remain enabled, including for
|
||||
Basic Auth API requests. Keep any existing NPM access lists in place.
|
||||
|
||||
Nginx uses the connecting address. If another proxy/CDN precedes NPM, configure
|
||||
its real-IP trust only for that proxy's actual source networks; never trust all
|
||||
forwarded addresses. The application limits may be stricter, especially when
|
||||
several users share one connecting proxy IP.
|
||||
|
||||
Run `nginx -t` inside the NPM container before reloading. Preserve existing custom
|
||||
configuration rather than replacing it. NPM's documented include points and
|
||||
Docker networking pattern are described in its [advanced configuration guide](https://nginxproxymanager.com/advanced-config/).
|
||||
|
||||
## Intentional domain root
|
||||
|
||||
Append `deploy/npm-tools-root.conf` only to the shared tools.coreplay.eu Proxy
|
||||
Host. Its exact `/` location returns 404 without changing the existing app path
|
||||
locations. Do not apply this root snippet to dedicated app hosts, where `/` is
|
||||
an application page. Once every app has migrated, remove the old locations and
|
||||
use NPM's 404 host for the retired tools hostname.
|
||||
|
||||
## Verify after rollout
|
||||
|
||||
From outside the VPS, inspect each login page's HTTPS headers and cookie flags;
|
||||
confirm unauthenticated sensitive APIs are denied and cross-origin mutations are
|
||||
rejected. Check `docker ps --format 'table {{.Names}}\t{{.Ports}}'` and the host
|
||||
firewall: no app backend should be reachable through the public IP. Confirm the
|
||||
root returns 404 and app login/navigation still work. Review NPM/app logs for
|
||||
429s and CSP violations after rollout. Existing data must remain available.
|
||||
@@ -0,0 +1,12 @@
|
||||
# Merge with ../docker-compose.yaml; requires Docker Compose support for !reset.
|
||||
# Create coreplay-proxy first and attach NPM to it as well.
|
||||
services:
|
||||
kaizoku:
|
||||
ports: !reset []
|
||||
networks:
|
||||
- default
|
||||
- coreplay_proxy
|
||||
networks:
|
||||
coreplay_proxy:
|
||||
external: true
|
||||
name: coreplay-proxy
|
||||
@@ -0,0 +1,12 @@
|
||||
# Include ONCE in nginx's http context (NPM: /data/nginx/custom/http_top.conf).
|
||||
# Empty keys bypass throttling; ordinary page/API polling is unaffected.
|
||||
map "$request_method:$uri" $coreplay_login_client {
|
||||
default "";
|
||||
"POST:/pwatcher/api/auth/login" $binary_remote_addr;
|
||||
"POST:/api/auth/login" $binary_remote_addr;
|
||||
"POST:/cbzcleaner/login" $binary_remote_addr;
|
||||
"POST:/login" $binary_remote_addr;
|
||||
"POST:/kaizoku/auth/login" $binary_remote_addr;
|
||||
"POST:/auth/login" $binary_remote_addr;
|
||||
}
|
||||
limit_req_zone $coreplay_login_client zone=coreplay_login:10m rate=5r/m;
|
||||
@@ -0,0 +1,4 @@
|
||||
# Add to each affected NPM Proxy Host's Advanced configuration.
|
||||
# Requires coreplay-security-http.conf to be loaded in the http context first.
|
||||
limit_req zone=coreplay_login burst=5 nodelay;
|
||||
limit_req_status 429;
|
||||
@@ -0,0 +1,5 @@
|
||||
# Add ONLY to the shared tools.coreplay.eu Proxy Host's Advanced configuration.
|
||||
# Keep existing /pwatcher, /cbzcleaner and /kaizoku custom locations.
|
||||
location = / {
|
||||
return 404;
|
||||
}
|
||||
+1
-1
@@ -7,7 +7,7 @@ services:
|
||||
container_name: kaizoku
|
||||
restart: unless-stopped
|
||||
ports:
|
||||
- "${KAIZOKU_PORT:-8421}:8421"
|
||||
- "${KAIZOKU_BIND_ADDRESS:-127.0.0.1}:${KAIZOKU_PORT:-8421}:8421"
|
||||
environment:
|
||||
USER_UID: ${USER_UID:-}
|
||||
USER_GID: ${USER_GID:-}
|
||||
|
||||
+37
-9
@@ -12,7 +12,7 @@ import json
|
||||
import mimetypes
|
||||
import shutil
|
||||
import traceback
|
||||
from base64 import b64decode
|
||||
from base64 import b64decode, b64encode
|
||||
from binascii import Error as BinasciiError
|
||||
from dataclasses import dataclass
|
||||
from http import HTTPStatus
|
||||
@@ -390,9 +390,6 @@ class Handler(BaseHTTPRequestHandler):
|
||||
canonical = urlparse(Handler._base_url(self))
|
||||
if canonical.netloc:
|
||||
return canonical.netloc
|
||||
host = str(self.headers.get("X-Forwarded-Host") or self.headers.get("x-forwarded-host") or "").strip()
|
||||
if host:
|
||||
return host.split(",", 1)[0].strip()
|
||||
return str(self.headers.get("Host") or self.headers.get("host") or "").strip()
|
||||
|
||||
def _origin(self):
|
||||
@@ -405,6 +402,9 @@ class Handler(BaseHTTPRequestHandler):
|
||||
canonical = urlparse(Handler._base_url(self))
|
||||
if canonical.scheme:
|
||||
return canonical.scheme == "https"
|
||||
# Forwarded headers have authority only when the socket peer is local.
|
||||
if not self.client_address or not client_address_is_local(self.client_address[0]):
|
||||
return False
|
||||
forwarded_proto = str(self.headers.get("X-Forwarded-Proto") or self.headers.get("x-forwarded-proto") or "").strip()
|
||||
if forwarded_proto:
|
||||
return forwarded_proto.split(",", 1)[0].strip().lower() == "https"
|
||||
@@ -712,6 +712,8 @@ class Handler(BaseHTTPRequestHandler):
|
||||
)
|
||||
|
||||
def enforce_same_origin(self):
|
||||
if self.headers.get("Sec-Fetch-Site") == "cross-site":
|
||||
raise PermissionError("Cross-site browser requests are not allowed.")
|
||||
origin = Handler._origin(self)
|
||||
if not origin:
|
||||
if Handler._session_cookie(self):
|
||||
@@ -723,9 +725,15 @@ class Handler(BaseHTTPRequestHandler):
|
||||
def _remote_path_roots(self):
|
||||
return configured_remote_path_roots(Handler._context(self).get_config_snapshot())
|
||||
|
||||
def _unrestricted_local_paths(self):
|
||||
# A public proxy may use a loopback socket and omit forwarded headers.
|
||||
# Public installations must still enforce the server-side filesystem roots.
|
||||
return (client_address_is_local(Handler._effective_client_host(self))
|
||||
and not Handler._base_url(self)
|
||||
and not remote_access_credentials_configured(Handler._config(self)))
|
||||
|
||||
def validate_remote_path(self, path_value, label):
|
||||
client_host = Handler._effective_client_host(self)
|
||||
if client_address_is_local(client_host):
|
||||
if Handler._unrestricted_local_paths(self):
|
||||
return
|
||||
roots = Handler._remote_path_roots(self)
|
||||
if not roots:
|
||||
@@ -793,8 +801,9 @@ class Handler(BaseHTTPRequestHandler):
|
||||
self.json(Handler._context(self).get_provider_update_status())
|
||||
elif parsed.path == "/api/fs/browse":
|
||||
params = parse_qs(parsed.query)
|
||||
client_host = Handler._effective_client_host(self)
|
||||
allowed_roots = None if client_address_is_local(client_host) else Handler._remote_path_roots(self)
|
||||
allowed_roots = None if Handler._unrestricted_local_paths(self) else Handler._remote_path_roots(self)
|
||||
if allowed_roots == []:
|
||||
raise PermissionError("Remote filesystem browsing requires configured path roots.")
|
||||
self.json(
|
||||
browse_filesystem(
|
||||
(params.get("path") or [""])[0],
|
||||
@@ -934,6 +943,8 @@ class Handler(BaseHTTPRequestHandler):
|
||||
payload = Handler.body_form(self)
|
||||
if not Handler._check_login_token(self, payload.get("csrf")):
|
||||
raise PermissionError("Sign-in form expired. Reload the page and try again.")
|
||||
if self.headers.get("Sec-Fetch-Site") == "cross-site":
|
||||
raise PermissionError("Cross-site sign-in is not allowed.")
|
||||
if Handler._origin(self) and not Handler._origin_matches_host(self):
|
||||
raise PermissionError("Cross-origin sign-in is not allowed.")
|
||||
username = str(payload.get("username") or "").strip()
|
||||
@@ -1279,15 +1290,32 @@ class Handler(BaseHTTPRequestHandler):
|
||||
headers = dict(headers)
|
||||
content_type = headers.get("Content-Type", "")
|
||||
base = Handler._base_path(self)
|
||||
# Only scripts from the application's trusted page templates may run.
|
||||
# Do not authorize arbitrary script tags found in a response body.
|
||||
scripts = []
|
||||
if "text/html" in content_type:
|
||||
context = Handler._context(self)
|
||||
templates = [getattr(context, name, None) for name in
|
||||
("index_html", "queue_html", "config_html", "watchlist_html")]
|
||||
if payload.decode("utf-8") in [*templates, AI_SUBTITLES_HTML]:
|
||||
scripts = re.findall(r"<script\b[^>]*>(.*?)</script\s*>", payload.decode("utf-8"), re.DOTALL | re.IGNORECASE)
|
||||
if base and "text/html" in content_type:
|
||||
content = payload.decode("utf-8")
|
||||
content = re.sub(r"([\"'`])/(?=api/|auth/|favicon\.|queue[\"'`?#]|config[\"'`?#]|watchlist[\"'`?#]|ai-subtitles[\"'`?#]|[\"'`])",
|
||||
lambda match: match[1] + base + "/", content)
|
||||
payload = content.encode("utf-8")
|
||||
# Mount rewriting also changes trusted script text.
|
||||
if scripts:
|
||||
scripts = re.findall(r"<script\b[^>]*>(.*?)</script\s*>", content, re.DOTALL | re.IGNORECASE)
|
||||
hashes = " ".join("'sha256-" + b64encode(hashlib.sha256(script.encode()).digest()).decode() + "'" for script in scripts)
|
||||
headers.setdefault("Cache-Control", "no-store")
|
||||
headers.setdefault("X-Content-Type-Options", "nosniff")
|
||||
headers.setdefault("Referrer-Policy", "same-origin")
|
||||
headers.setdefault("Content-Security-Policy", "frame-ancestors 'none'; base-uri 'self'; form-action 'self'; object-src 'none'")
|
||||
headers.setdefault("Content-Security-Policy", f"default-src 'self'; script-src 'self' {hashes}; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'; object-src 'none'")
|
||||
headers.setdefault("X-Frame-Options", "DENY")
|
||||
headers.setdefault("Permissions-Policy", "camera=(), microphone=(), geolocation=()")
|
||||
if Handler._request_is_secure(self):
|
||||
headers.setdefault("Strict-Transport-Security", "max-age=31536000")
|
||||
self.send_response(status)
|
||||
for key, value in headers.items():
|
||||
self.send_header(key, value)
|
||||
|
||||
+3
-1
@@ -430,6 +430,7 @@ class NetworkGuardTests(unittest.TestCase):
|
||||
"KAIZOKU_ALLOW_REMOTE": "1",
|
||||
"KAIZOKU_AUTH_USERNAME": "demo",
|
||||
"KAIZOKU_AUTH_PASSWORD": "secret-pass",
|
||||
"KAIZOKU_BASE_URL": "https://anime.example:8421",
|
||||
},
|
||||
clear=False,
|
||||
):
|
||||
@@ -5002,7 +5003,8 @@ class HandlerRouteTests(unittest.TestCase):
|
||||
post_body = b'{"download_dir":"/tmp/updated","mode":"dub","quality":"720"}'
|
||||
post_handler = DummyHandler("/api/config", body=post_body, content_length=len(post_body))
|
||||
post_handler.headers["Authorization"] = "Basic " + base64.b64encode(b"demo:secret-pass").decode()
|
||||
APP.Handler.do_POST(post_handler)
|
||||
with mock.patch.dict(os.environ, {"KAIZOKU_REMOTE_PATH_ROOTS": "/tmp/updated"}):
|
||||
APP.Handler.do_POST(post_handler)
|
||||
|
||||
self.assertEqual(post_handler.json_status, HTTPStatus.OK)
|
||||
self.assertNotIn("auth_username", post_handler.json_payload)
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
"""Exercise the public proxy contract without touching an existing installation."""
|
||||
import json
|
||||
import hashlib
|
||||
from base64 import b64encode
|
||||
import os
|
||||
import re
|
||||
import unittest
|
||||
@@ -121,6 +123,41 @@ class ProxyAuthTests(unittest.TestCase):
|
||||
for value in ("//evil.test", "/\\evil.test", "https://evil.test", "/\r\nLocation: bad"):
|
||||
self.assertEqual(APP.Handler._normalized_next_path(handler, value), "/")
|
||||
|
||||
def test_public_proxy_loopback_cannot_bypass_filesystem_roots(self):
|
||||
handler = self.handler("/kaizoku/api/fs/browse")
|
||||
with mock.patch.object(http_handler, "configured_remote_path_roots", return_value=[]):
|
||||
with self.assertRaises(PermissionError):
|
||||
APP.Handler.validate_remote_path(handler, "/etc", "download directory")
|
||||
self.assertFalse(APP.Handler._unrestricted_local_paths(handler))
|
||||
with mock.patch.object(http_handler, "configured_remote_path_roots", return_value=["/downloads"]):
|
||||
with self.assertRaises(PermissionError):
|
||||
APP.Handler.validate_remote_path(handler, "/etc", "download directory")
|
||||
APP.Handler.validate_remote_path(handler, "/downloads/show", "download directory")
|
||||
|
||||
def test_csp_authorizes_only_trusted_scripts_after_mount_rewriting(self):
|
||||
handler = self.handler("/kaizoku/")
|
||||
trusted = handler.handler_context.index_html
|
||||
APP.Handler.html(handler, trusted)
|
||||
headers = dict(handler.response_headers)
|
||||
policy = headers["Content-Security-Policy"]
|
||||
script = re.search(r"<script>(.*?)</script>", handler.wfile.getvalue().decode(), re.S)[1]
|
||||
digest = b64encode(hashlib.sha256(script.encode()).digest()).decode()
|
||||
self.assertIn("'sha256-" + digest + "'", policy)
|
||||
self.assertNotIn("'unsafe-inline'", policy.split("style-src")[0])
|
||||
self.assertEqual(headers["Strict-Transport-Security"], "max-age=31536000")
|
||||
injected = self.handler("/kaizoku/")
|
||||
APP.Handler.html(injected, '<script>alert("injected")</script>')
|
||||
self.assertNotIn("sha256-", dict(injected.response_headers)["Content-Security-Policy"])
|
||||
|
||||
def test_cross_site_metadata_and_untrusted_forwarded_host_are_rejected(self):
|
||||
handler = self.handler("/kaizoku/")
|
||||
handler.headers["Sec-Fetch-Site"] = "cross-site"
|
||||
with self.assertRaises(PermissionError):
|
||||
APP.Handler.enforce_same_origin(handler)
|
||||
self.config["base_url"] = ""
|
||||
handler.headers.update({"X-Forwarded-Host": "evil.example", "Origin": "http://evil.example"})
|
||||
self.assertFalse(APP.Handler._origin_matches_host(handler))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user