Harden public proxy access, filesystem boundaries and content policy

This commit is contained in:
Dymas committed 2026-10-24 11:11:42 +02:00
1 parent 219e64f5a2
commit d5ac22777f
12 files changed
+213 -14

No files matched your search

+7
View File
@@ -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.
+9 -2
View File
@@ -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.
+85
View File
@@ -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.
+1 -1
View File
@@ -1 +1 @@
0.55.1
0.55.2
+12
View File
@@ -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
+12
View File
@@ -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;
+4
View File
@@ -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;
+5
View File
@@ -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
View File
@@ -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
View File
@@ -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
View File
@@ -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)
+37
View File
@@ -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()