320 lines
11 KiB
Python
320 lines
11 KiB
Python
import ipaddress
|
|
import json
|
|
import os
|
|
import re
|
|
import sqlite3
|
|
import tomllib
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
from urllib.parse import urlsplit
|
|
|
|
from fastapi import FastAPI, HTTPException, Request
|
|
from fastapi.responses import HTMLResponse, JSONResponse, PlainTextResponse
|
|
from pydantic import BaseModel, Field, field_validator
|
|
|
|
ROOT = Path(__file__).resolve().parent.parent
|
|
DB_PATH = Path(os.environ.get("PAC_ROUTER_DB", str(ROOT / "router.db")))
|
|
DEFAULT_HOST = os.environ.get("PAC_UPSTREAM_HOST", "127.0.0.1")
|
|
DEFAULT_PORT = int(os.environ.get("PAC_UPSTREAM_PORT", "3128"))
|
|
DOMAIN_RE = re.compile(r"^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$")
|
|
def server_config():
|
|
with (ROOT / "config.toml").open("rb") as f:
|
|
config = tomllib.load(f)
|
|
server = config["server"]
|
|
host = os.environ.get("PAC_UI_HOST", server["host"])
|
|
port = int(os.environ.get("PAC_UI_PORT", server["port"]))
|
|
if not isinstance(host, str) or not host:
|
|
raise ValueError("server.host must be a nonempty string")
|
|
if type(port) is not int or not 1 <= port <= 65535:
|
|
raise ValueError("server.port must be an integer between 1 and 65535")
|
|
return host, port
|
|
|
|
|
|
def proxy_server_config():
|
|
with (ROOT / "config.toml").open("rb") as f:
|
|
config = tomllib.load(f)
|
|
proxy = config.get("proxy_server", {"host": "127.0.0.1", "port": 25667})
|
|
host = os.environ.get("PAC_PROXY_HOST", proxy["host"])
|
|
port = int(os.environ.get("PAC_PROXY_PORT", proxy["port"]))
|
|
if host not in ("127.0.0.1", "localhost", "::1") and os.environ.get("PAC_ALLOW_NON_LOOPBACK") != "1":
|
|
raise ValueError("proxy_server.host must be a loopback address")
|
|
if type(port) is not int or not 1 <= port <= 65535:
|
|
raise ValueError("proxy_server.port must be an integer between 1 and 65535")
|
|
return host, port
|
|
|
|
|
|
app = FastAPI(title="PAC Router", docs_url=None, redoc_url=None, openapi_url=None)
|
|
|
|
|
|
def validate_domain(raw: str) -> str:
|
|
value = raw.strip().lower().rstrip(".")
|
|
if value.startswith("*."):
|
|
base = value[2:]
|
|
else:
|
|
base = value
|
|
if not base or len(base) > 253 or not DOMAIN_RE.fullmatch(base):
|
|
raise ValueError("Use a hostname or *.hostname (ASCII/IDNA); no URLs or ports")
|
|
if "." not in base and base != "localhost":
|
|
raise ValueError("Domain must contain a dot")
|
|
return value
|
|
|
|
|
|
def validate_proxy(host: str, port: int):
|
|
try:
|
|
ipaddress.ip_address(host)
|
|
except ValueError:
|
|
if not DOMAIN_RE.fullmatch(host) or len(host) > 253:
|
|
raise ValueError("Invalid proxy host")
|
|
if not 1 <= port <= 65535:
|
|
raise ValueError("Invalid proxy port")
|
|
|
|
|
|
class RuleIn(BaseModel):
|
|
domain: str = Field(min_length=1, max_length=260)
|
|
route: str = "PROXY"
|
|
enabled: bool = True
|
|
|
|
@field_validator("domain")
|
|
@classmethod
|
|
def domain_valid(cls, v):
|
|
return validate_domain(v)
|
|
|
|
@field_validator("route")
|
|
@classmethod
|
|
def route_valid(cls, v):
|
|
if v not in ("PROXY", "DIRECT"):
|
|
raise ValueError("Route must be PROXY or DIRECT")
|
|
return v
|
|
|
|
|
|
class SettingsIn(BaseModel):
|
|
proxy_host: str
|
|
proxy_port: int
|
|
default_route: str = "DIRECT"
|
|
|
|
@field_validator("default_route")
|
|
@classmethod
|
|
def route_valid(cls, v):
|
|
if v not in ("DIRECT", "PROXY"):
|
|
raise ValueError("Invalid route")
|
|
return v
|
|
|
|
@field_validator("proxy_host")
|
|
@classmethod
|
|
def host_valid(cls, v):
|
|
v = v.strip().lower()
|
|
validate_proxy(v, 1)
|
|
return v
|
|
|
|
@field_validator("proxy_port")
|
|
@classmethod
|
|
def port_valid(cls, v):
|
|
validate_proxy("127.0.0.1", v)
|
|
return v
|
|
|
|
|
|
@contextmanager
|
|
def db():
|
|
DB_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
con = sqlite3.connect(DB_PATH, timeout=10)
|
|
con.row_factory = sqlite3.Row
|
|
try:
|
|
yield con
|
|
con.commit()
|
|
finally:
|
|
con.close()
|
|
|
|
|
|
def initialize():
|
|
validate_proxy(DEFAULT_HOST, DEFAULT_PORT)
|
|
with db() as con:
|
|
con.execute("CREATE TABLE IF NOT EXISTS rules (id INTEGER PRIMARY KEY, domain TEXT NOT NULL UNIQUE, route TEXT NOT NULL, enabled INTEGER NOT NULL DEFAULT 1)")
|
|
con.execute("CREATE TABLE IF NOT EXISTS settings (key TEXT PRIMARY KEY, value TEXT NOT NULL)")
|
|
con.execute("INSERT OR IGNORE INTO settings VALUES ('proxy_host', ?)", (DEFAULT_HOST,))
|
|
con.execute("INSERT OR IGNORE INTO settings VALUES ('proxy_port', ?)", (str(DEFAULT_PORT),))
|
|
con.execute("INSERT OR IGNORE INTO settings VALUES ('default_route', 'DIRECT')")
|
|
|
|
|
|
initialize()
|
|
|
|
|
|
def settings():
|
|
with db() as con:
|
|
d = {r["key"]: r["value"] for r in con.execute("SELECT key, value FROM settings")}
|
|
return {"proxy_host": d["proxy_host"], "proxy_port": int(d["proxy_port"]), "default_route": d["default_route"]}
|
|
|
|
|
|
def rules():
|
|
with db() as con:
|
|
return [dict(r) | {"enabled": bool(r["enabled"])} for r in con.execute("SELECT * FROM rules ORDER BY id")]
|
|
|
|
|
|
def match(pattern, host):
|
|
if pattern.startswith("*."):
|
|
base = pattern[2:]
|
|
return host.endswith("." + base)
|
|
return pattern == host
|
|
|
|
|
|
def route_for(host):
|
|
host = host.strip().lower().rstrip(".")
|
|
active = [r for r in rules() if r["enabled"] and match(r["domain"], host)]
|
|
# Exact matches outrank wildcards; longer suffix outranks shorter; id breaks ties.
|
|
active.sort(key=lambda r: (not r["domain"].startswith("*."), len(r["domain"]), -r["id"]), reverse=True)
|
|
selected = active[0] if active else None
|
|
return {"route": selected["route"] if selected else settings()["default_route"], "rule": selected}
|
|
|
|
|
|
def pac():
|
|
s = settings()
|
|
proxy = f'PROXY {s["proxy_host"]}:{s["proxy_port"]}'
|
|
active = [r for r in rules() if r["enabled"]]
|
|
active.sort(key=lambda r: (not r["domain"].startswith("*."), len(r["domain"]), -r["id"]), reverse=True)
|
|
lines = [
|
|
"// Generated by PAC Router. No fallback to DIRECT for PROXY routes.",
|
|
"function FindProxyForURL(url, host) {",
|
|
" host = host.toLowerCase().replace(/\\.$/, '');",
|
|
]
|
|
for r in active:
|
|
domain = r["domain"]
|
|
if domain.startswith("*."):
|
|
base = domain[2:]
|
|
condition = f'dnsDomainIs(host, {json.dumps("." + base)})'
|
|
else:
|
|
condition = f'host === {json.dumps(domain)}'
|
|
target = proxy if r["route"] == "PROXY" else "DIRECT"
|
|
lines.append(f" if ({condition}) return {json.dumps(target)};")
|
|
target = proxy if s["default_route"] == "PROXY" else "DIRECT"
|
|
lines += [f" return {json.dumps(target)};", "}", ""]
|
|
return "\n".join(lines)
|
|
|
|
|
|
@app.middleware("http")
|
|
async def protect(request: Request, call_next):
|
|
# Localhost-only deployment, plus reject cross-site browser writes.
|
|
if request.method not in ("GET", "HEAD", "OPTIONS"):
|
|
origin = request.headers.get("origin")
|
|
if origin:
|
|
try:
|
|
parsed = urlsplit(origin)
|
|
valid = parsed.scheme == "http" and parsed.hostname in ("127.0.0.1", "localhost") and parsed.port == server_config()[1]
|
|
except ValueError:
|
|
valid = False
|
|
if not valid:
|
|
return JSONResponse({"detail": "Cross-origin write rejected"}, status_code=403)
|
|
elif request.headers.get("sec-fetch-site") == "cross-site":
|
|
return JSONResponse({"detail": "Cross-site write rejected"}, status_code=403)
|
|
return await call_next(request)
|
|
|
|
|
|
@app.get("/", response_class=HTMLResponse)
|
|
def home():
|
|
return (ROOT / "app" / "index.html").read_text(encoding="utf-8")
|
|
|
|
|
|
@app.get("/proxy.pac")
|
|
def get_pac():
|
|
return PlainTextResponse(pac(), media_type="application/x-ns-proxy-autoconfig", headers={"Cache-Control": "no-store, max-age=0"})
|
|
|
|
|
|
@app.get("/api/state")
|
|
def state():
|
|
return {"settings": settings(), "rules": rules()}
|
|
|
|
|
|
@app.put("/api/settings")
|
|
def update_settings(data: SettingsIn):
|
|
with db() as con:
|
|
for k, v in data.model_dump().items():
|
|
con.execute("INSERT OR REPLACE INTO settings (key,value) VALUES (?,?)", (k, str(v)))
|
|
return settings()
|
|
|
|
|
|
@app.post("/api/rules", status_code=201)
|
|
def create_rule(data: RuleIn):
|
|
try:
|
|
with db() as con:
|
|
cur = con.execute("INSERT INTO rules(domain,route,enabled) VALUES (?,?,?)", (data.domain, data.route, int(data.enabled)))
|
|
return {"id": cur.lastrowid}
|
|
except sqlite3.IntegrityError:
|
|
raise HTTPException(409, "Domain already exists")
|
|
|
|
|
|
@app.put("/api/rules/{rule_id}")
|
|
def update_rule(rule_id: int, data: RuleIn):
|
|
try:
|
|
with db() as con:
|
|
cur = con.execute("UPDATE rules SET domain=?, route=?, enabled=? WHERE id=?", (data.domain, data.route, int(data.enabled), rule_id))
|
|
if not cur.rowcount:
|
|
raise HTTPException(404, "Rule not found")
|
|
except sqlite3.IntegrityError:
|
|
raise HTTPException(409, "Domain already exists")
|
|
return {"ok": True}
|
|
|
|
|
|
@app.delete("/api/rules/{rule_id}")
|
|
def delete_rule(rule_id: int):
|
|
with db() as con:
|
|
cur = con.execute("DELETE FROM rules WHERE id=?", (rule_id,))
|
|
if not cur.rowcount:
|
|
raise HTTPException(404, "Rule not found")
|
|
return {"ok": True}
|
|
|
|
|
|
@app.get("/api/test")
|
|
def test(host: str):
|
|
try:
|
|
host = validate_domain(host)
|
|
if host.startswith("*."):
|
|
raise ValueError("Enter an actual hostname")
|
|
except ValueError as exc:
|
|
raise HTTPException(422, str(exc))
|
|
return route_for(host)
|
|
|
|
|
|
@app.get("/api/export")
|
|
def export():
|
|
return {"version": 1, "settings": settings(), "rules": [{k: r[k] for k in ("domain", "route", "enabled")} for r in rules()]}
|
|
|
|
|
|
class ImportIn(BaseModel):
|
|
version: int
|
|
settings: SettingsIn
|
|
rules: list[RuleIn] = Field(max_length=10000)
|
|
|
|
|
|
@app.post("/api/import")
|
|
def import_data(data: ImportIn):
|
|
if data.version != 1:
|
|
raise HTTPException(422, "Unsupported export version")
|
|
names = [r.domain for r in data.rules]
|
|
if len(names) != len(set(names)):
|
|
raise HTTPException(422, "Duplicate domains")
|
|
with db() as con:
|
|
con.execute("DELETE FROM rules")
|
|
for r in data.rules:
|
|
con.execute("INSERT INTO rules(domain,route,enabled) VALUES (?,?,?)", (r.domain, r.route, int(r.enabled)))
|
|
for k, v in data.settings.model_dump().items():
|
|
con.execute("INSERT OR REPLACE INTO settings(key,value) VALUES (?,?)", (k, str(v)))
|
|
return {"ok": True}
|
|
|
|
|
|
def main():
|
|
import asyncio
|
|
import uvicorn
|
|
from app.proxy import start_proxy
|
|
|
|
host, port = server_config()
|
|
if host not in ("127.0.0.1", "localhost", "::1") and os.environ.get("PAC_ALLOW_NON_LOOPBACK") != "1":
|
|
raise ValueError("Only loopback binding is supported for security reasons")
|
|
proxy_host, proxy_port = proxy_server_config()
|
|
|
|
async def serve():
|
|
proxy = await start_proxy(proxy_host, proxy_port, route_for, settings)
|
|
web = uvicorn.Server(uvicorn.Config(app, host=host, port=port))
|
|
print(f"Routing proxy listening on http://{proxy_host}:{proxy_port}")
|
|
async with proxy:
|
|
await web.serve()
|
|
|
|
asyncio.run(serve())
|