forked from retoor/devplacepy
129 lines
4.2 KiB
JavaScript
129 lines
4.2 KiB
JavaScript
import {
|
|
ALLOWED_PORTS,
|
|
DESTINATIONS,
|
|
HTTPS_PORT,
|
|
LIMITS,
|
|
MODE_FETCH,
|
|
REFUSALS,
|
|
} from "./spec.js";
|
|
|
|
const HTTPS = "https:";
|
|
|
|
function isSubset(candidate, allowed) {
|
|
return Array.isArray(candidate) && candidate.every((item) => allowed.includes(item));
|
|
}
|
|
|
|
function normaliseHost(host) {
|
|
return String(host).trim().toLowerCase().replace(/\.+$/, "");
|
|
}
|
|
|
|
export class Policy {
|
|
constructor(destinations = DESTINATIONS, limits = LIMITS) {
|
|
this.destinations = destinations;
|
|
this.urlMaxChars = limits.url_max_chars;
|
|
}
|
|
|
|
static narrow(baked, refreshed) {
|
|
const accepted = [];
|
|
const rejected = [];
|
|
if (!Array.isArray(refreshed)) {
|
|
return { destinations: [], rejected: ["destinations is not a list"] };
|
|
}
|
|
for (const item of refreshed) {
|
|
const suffix = item && typeof item.suffix === "string" ? normaliseHost(item.suffix) : "";
|
|
const parent = baked.find(
|
|
(entry) => suffix === entry.suffix || suffix.endsWith("." + entry.suffix),
|
|
);
|
|
if (!parent) {
|
|
rejected.push(`${suffix || "?"}: not in the baked-in allowlist`);
|
|
continue;
|
|
}
|
|
const methods = Array.isArray(item.methods) ? item.methods.map((m) => String(m).toUpperCase()) : [];
|
|
const ports = Array.isArray(item.ports) ? item.ports : [];
|
|
const modes = Array.isArray(item.modes) ? item.modes : [];
|
|
if (!methods.length || !isSubset(methods, parent.methods)) {
|
|
rejected.push(`${suffix}: methods widen the baked-in list`);
|
|
continue;
|
|
}
|
|
if (!ports.length || !isSubset(ports, parent.ports) || !isSubset(ports, ALLOWED_PORTS)) {
|
|
rejected.push(`${suffix}: ports widen the baked-in list`);
|
|
continue;
|
|
}
|
|
if (!modes.includes(MODE_FETCH)) {
|
|
rejected.push(`${suffix}: not available in fetch mode`);
|
|
continue;
|
|
}
|
|
accepted.push({
|
|
suffix,
|
|
adapter: String(item.adapter || parent.adapter),
|
|
methods,
|
|
ports,
|
|
modes,
|
|
max_rps: typeof item.max_rps === "number" ? item.max_rps : parent.max_rps,
|
|
});
|
|
}
|
|
return { destinations: accepted, rejected };
|
|
}
|
|
|
|
static fromRefreshed(baked, refreshed, limits = LIMITS) {
|
|
const narrowed = Policy.narrow(baked, refreshed);
|
|
return { policy: new Policy(narrowed.destinations, limits), rejected: narrowed.rejected };
|
|
}
|
|
|
|
destinationFor(host) {
|
|
const name = normaliseHost(host);
|
|
return (
|
|
this.destinations.find((item) => name === item.suffix || name.endsWith("." + item.suffix)) || null
|
|
);
|
|
}
|
|
|
|
refuse(code, reason) {
|
|
return { ok: false, code, reason };
|
|
}
|
|
|
|
check(method, rawUrl) {
|
|
if (typeof rawUrl !== "string" || !rawUrl || rawUrl.length > this.urlMaxChars) {
|
|
return this.refuse(REFUSALS.HOST_NOT_ALLOWED, "url is missing or too long");
|
|
}
|
|
let url;
|
|
try {
|
|
url = new URL(rawUrl);
|
|
} catch (error) {
|
|
return this.refuse(REFUSALS.HOST_NOT_ALLOWED, "url does not parse");
|
|
}
|
|
if (url.protocol !== HTTPS) {
|
|
return this.refuse(REFUSALS.HOST_NOT_ALLOWED, "only https is allowed");
|
|
}
|
|
if (url.username || url.password) {
|
|
return this.refuse(REFUSALS.HOST_NOT_ALLOWED, "credentials in the url are refused");
|
|
}
|
|
const destination = this.destinationFor(url.hostname);
|
|
if (!destination) {
|
|
return this.refuse(REFUSALS.HOST_NOT_ALLOWED, `${url.hostname} is not on the allowlist`);
|
|
}
|
|
const port = url.port === "" ? HTTPS_PORT : Number(url.port);
|
|
if (port !== HTTPS_PORT || !destination.ports.includes(port) || !ALLOWED_PORTS.includes(port)) {
|
|
return this.refuse(REFUSALS.PORT_NOT_ALLOWED, `port ${port} is not allowed over https`);
|
|
}
|
|
const verb = String(method || "").toUpperCase();
|
|
if (!destination.methods.includes(verb)) {
|
|
return this.refuse(REFUSALS.METHOD_NOT_ALLOWED, `${verb || "?"} is not permitted`);
|
|
}
|
|
return { ok: true, url, destination, method: verb };
|
|
}
|
|
|
|
checkRedirect(location, base, method) {
|
|
let target;
|
|
try {
|
|
target = new URL(location, base);
|
|
} catch (error) {
|
|
return this.refuse(REFUSALS.REDIRECT_NOT_ALLOWED, "redirect target does not parse");
|
|
}
|
|
const verdict = this.check(method, target.href);
|
|
if (!verdict.ok) {
|
|
return this.refuse(REFUSALS.REDIRECT_NOT_ALLOWED, verdict.reason);
|
|
}
|
|
return verdict;
|
|
}
|
|
}
|