matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/core/events.js

@@ -0,0 +1,186 @@
+import { canonicalJson, isObject } from "./json.js";
+import { randomString, sha256, signJson, unpaddedBase64, urlSafeBase64 } from "./crypto.js";
+import { M } from "./m.js";
+//#region src/core/events.ts
+const STABLE_ROOM_VERSIONS = [
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"10",
+	"11",
+	"12"
+];
+/** Experimental versions: an MSC's changes on top of a stable version. */
+const UNSTABLE_ROOM_VERSIONS = [
+	"org.matrix.msc3757.10",
+	"org.matrix.msc3757.11",
+	"org.matrix.msc3389.10"
+];
+const SUPPORTED_ROOM_VERSIONS = [...STABLE_ROOM_VERSIONS, ...UNSTABLE_ROOM_VERSIONS];
+/** The stable version an (experimental) room version is based on, e.g. "org.matrix.msc3757.10" → 10. */
+const versionNum = (v) => {
+	let start = v.length;
+	while (start > 0 && v.charCodeAt(start - 1) >= 48 && v.charCodeAt(start - 1) <= 57) start--;
+	return Number.parseInt(start < v.length ? v.slice(start) : v, 10);
+};
+const roomVersionFeatures = (version) => {
+	const n = versionNum(version);
+	return {
+		/** v1/v2 use server-generated event IDs and `[id, hashes]` tuples in prev/auth events. */
+		legacyEventIds: n <= 2,
+		urlSafeEventIds: n >= 4,
+		knock: n >= 7,
+		restricted: n >= 8,
+		knockRestricted: n >= 10,
+		integerPowerLevels: n >= 10,
+		/** v11: creator is the sender of the create event; `redacts` moves into content. */
+		v11: n >= 11,
+		/**
+		* v12: room ID is the create event's reference hash, the create event has no room_id and is
+		* omitted from auth_events, and room creators have unlimited power.
+		*/
+		v12: n >= 12,
+		/** MSC3757: state keys "@user:server[_suffix]" are owned by that user. */
+		ownedState: version.startsWith("org.matrix.msc3757."),
+		/** MSC3389: redactions keep m.relates_to. */
+		redactionKeepsRelations: version.startsWith("org.matrix.msc3389.")
+	};
+};
+const KEEP_TOP_LEVEL = [
+	"event_id",
+	"type",
+	"room_id",
+	"sender",
+	"state_key",
+	"content",
+	"hashes",
+	"signatures",
+	"depth",
+	"prev_events",
+	"auth_events",
+	"origin_server_ts"
+];
+const KEEP_TOP_LEVEL_LEGACY = [
+	"prev_state",
+	"origin",
+	"membership"
+];
+/** Apply the redaction algorithm for the given room version. */
+function redact(event, roomVersion) {
+	const n = versionNum(roomVersion);
+	const keep = n >= 11 ? KEEP_TOP_LEVEL : [...KEEP_TOP_LEVEL, ...KEEP_TOP_LEVEL_LEGACY];
+	const out = {};
+	for (const k of keep) if (k in event) out[k] = event[k];
+	const keepRelation = roomVersion.startsWith("org.matrix.msc3389.") && isObject(event.content?.[M.RELATES_TO]) ? event.content[M.RELATES_TO] : void 0;
+	const content = isObject(event.content) ? event.content : {};
+	const pick = (...keys) => {
+		const c = {};
+		for (const k of keys) if (k in content) c[k] = content[k];
+		return c;
+	};
+	switch (event.type) {
+		case M.ROOM.MEMBER: {
+			const c = pick("membership", ...n >= 9 ? ["join_authorised_via_users_server"] : []);
+			if (n >= 11 && isObject(content.third_party_invite) && "signed" in content.third_party_invite) c.third_party_invite = { signed: content.third_party_invite.signed };
+			out.content = c;
+			break;
+		}
+		case M.ROOM.CREATE:
+			out.content = n >= 11 ? { ...content } : pick("creator");
+			break;
+		case M.ROOM.JOIN_RULES:
+			out.content = pick("join_rule", ...n >= 8 ? ["allow"] : []);
+			break;
+		case M.ROOM.POWER_LEVELS:
+			out.content = pick("ban", "events", "events_default", "kick", "redact", "state_default", "users", "users_default", ...n >= 11 ? ["invite"] : []);
+			break;
+		case M.ROOM.HISTORY_VISIBILITY:
+			out.content = pick("history_visibility");
+			break;
+		case M.ROOM.ALIASES:
+			out.content = n <= 5 ? pick("aliases") : {};
+			break;
+		case M.ROOM.REDACTION:
+			out.content = n >= 11 ? pick("redacts") : {};
+			break;
+		default: out.content = {};
+	}
+	if (keepRelation) {
+		const rel = {};
+		if ("rel_type" in keepRelation) rel.rel_type = keepRelation.rel_type;
+		if ("event_id" in keepRelation) rel.event_id = keepRelation.event_id;
+		out.content = {
+			...out.content,
+			[M.RELATES_TO]: rel
+		};
+	}
+	return out;
+}
+function computeContentHash(pdu) {
+	const { unsigned, signatures, hashes, ...rest } = pdu;
+	return unpaddedBase64(sha256(canonicalJson(rest)));
+}
+function computeReferenceHash(pdu, roomVersion) {
+	const { signatures, unsigned, event_id, ...rest } = redact(pdu, roomVersion);
+	return sha256(canonicalJson(rest));
+}
+/** Finalise a PDU: compute hashes, signatures and the event ID. */
+function finalisePdu(pdu, roomVersion, serverName, key) {
+	const features = roomVersionFeatures(roomVersion);
+	if (features.legacyEventIds) {
+		pdu.event_id = `$${randomString(18)}:${serverName}`;
+		pdu.origin = serverName;
+	}
+	pdu.hashes = { sha256: computeContentHash(pdu) };
+	const redacted = redact(pdu, roomVersion);
+	signJson(redacted, serverName, key);
+	pdu.signatures = redacted.signatures;
+	if (!features.legacyEventIds) {
+		const hash = computeReferenceHash(pdu, roomVersion);
+		pdu.event_id = `$${features.urlSafeEventIds ? urlSafeBase64(hash) : unpaddedBase64(hash)}`;
+	}
+	return pdu;
+}
+function eventIdOf(ref) {
+	return Array.isArray(ref) ? ref[0] : ref;
+}
+/** Convert a stored PDU into the client-server event format. */
+function toClientEvent(pdu, opts = {}) {
+	const ev = {
+		event_id: pdu.event_id,
+		sender: pdu.sender,
+		type: pdu.type,
+		content: pdu.content,
+		origin_server_ts: pdu.origin_server_ts
+	};
+	if (opts.includeRoomId !== false) ev.room_id = pdu.room_id;
+	if (pdu.state_key !== void 0) ev.state_key = pdu.state_key;
+	if (pdu.redacts !== void 0) ev.redacts = pdu.redacts;
+	else if (pdu.type === M.ROOM.REDACTION && typeof pdu.content?.redacts === "string") ev.redacts = pdu.content.redacts;
+	ev.unsigned = {
+		...pdu.unsigned,
+		age: Math.max(0, Date.now() - pdu.origin_server_ts)
+	};
+	return ev;
+}
+function stripState(pdu) {
+	return {
+		type: pdu.type,
+		state_key: pdu.state_key,
+		sender: pdu.sender,
+		content: pdu.content
+	};
+}
+const stateKey = (type, key) => `${type}\u0000${key}`;
+const splitStateKey = (k) => {
+	const i = k.indexOf("\0");
+	return [k.slice(0, i), k.slice(i + 1)];
+};
+//#endregion
+export { STABLE_ROOM_VERSIONS, SUPPORTED_ROOM_VERSIONS, UNSTABLE_ROOM_VERSIONS, computeContentHash, computeReferenceHash, eventIdOf, finalisePdu, redact, roomVersionFeatures, splitStateKey, stateKey, stripState, toClientEvent, versionNum };

package/dist/core/glob.js

@@ -0,0 +1,66 @@
+//#region src/core/glob.ts
+/**
+* Glob matching (`*` = any run of characters, `?` = one character) in linear time.
+*
+* Security fix (https://github.com/k18k/matrix-nodejs-homeserver/issues/2 — ReDoS, CWE-1333): globs from untrusted input (m.room.server_acl entries from
+* room state, MSC4155 invite rules from account data, event filters from clients) used to be
+* compiled to regular expressions with `.*`. A pattern such as `****************!` made the
+* regex engine backtrack exponentially: 16 asterisks blocked the event loop for ~110 s, so a
+* room ACL could hang the whole homeserver, again after every restart. This matcher never
+* backtracks more than once per character (classic two-pointer wildcard matching).
+*/
+function globMatch(pattern, value, opts = {}) {
+	const p = opts.caseInsensitive ? pattern.toLowerCase() : pattern;
+	const v = opts.caseInsensitive ? value.toLowerCase() : value;
+	const anyOne = opts.questionMark ?? true;
+	let pi = 0, vi = 0;
+	let star = -1, mark = 0;
+	while (vi < v.length) if (pi < p.length && (p[pi] === v[vi] || anyOne && p[pi] === "?")) {
+		pi++;
+		vi++;
+	} else if (pi < p.length && p[pi] === "*") {
+		star = ++pi;
+		mark = vi;
+	} else if (star !== -1) {
+		pi = star;
+		vi = ++mark;
+	} else return false;
+	while (pi < p.length && p[pi] === "*") pi++;
+	return pi === p.length;
+}
+const isWordChar = (c) => c !== void 0 && /[\p{L}\p{N}_]/u.test(c);
+/**
+* Whether `pattern` (a glob) matches some run of `value` that starts and ends on a word boundary,
+* as push rules match `content.body`. Case-insensitive.
+*
+* Security fix (https://github.com/k18k/matrix-nodejs-homeserver/issues/2 — ReDoS, CWE-1333): push rule patterns are set by any user and were compiled to
+* `(^|\W)…(\W|$)` regexes with `.*?`, then run against every message in the user's rooms, so one
+* account could hang the server. This simulates the glob as an automaton instead: the cost is
+* O(value length × pattern length) whatever the input, with no backtracking.
+*/
+function globSearchWords(pattern, value) {
+	const p = pattern.toLowerCase();
+	const v = value.toLowerCase();
+	const m = p.length;
+	let active = new Uint8Array(m + 1);
+	const close = (set) => {
+		for (let k = 0; k < m; k++) if (set[k] && p[k] === "*") set[k + 1] = 1;
+	};
+	for (let i = 0; i <= v.length; i++) {
+		if (!isWordChar(v[i - 1])) active[0] = 1;
+		close(active);
+		if (active[m] && !isWordChar(v[i])) return true;
+		if (i === v.length) break;
+		const next = new Uint8Array(m + 1);
+		const c = v[i];
+		for (let k = 0; k < m; k++) {
+			if (!active[k]) continue;
+			if (p[k] === "*") next[k] = 1;
+			else if (p[k] === "?" || p[k] === c) next[k + 1] = 1;
+		}
+		active = next;
+	}
+	return false;
+}
+//#endregion
+export { globMatch, globSearchWords };

package/dist/core/identity.d.ts

@@ -0,0 +1,24 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/core/identity.d.ts
+export interface StoredInvite {
+  token: string;
+  public_keys: {
+    public_key: string;
+    key_validity_url: string;
+  }[];
+  display_name: string;
+}
+export declare class IdentityServers {
+  private readonly hs;
+  constructor(hs: Homeserver);
+  private base;
+  private call;
+  /** The Matrix user ID bound to a 3PID, if any. */
+  lookup(idServer: string, token: string, medium: string, address: string): Promise<string | null>;
+  storeInvite(idServer: string, token: string, invite: Record<string, unknown>): Promise<StoredInvite>;
+  /** Returns the identity server's record of the binding (medium, address, mxid...). */
+  bind(idServer: string, token: string, sid: string, clientSecret: string, mxid: string): Promise<Record<string, any>>;
+  /** Remove a binding; resolves false when the identity server does not support unbinding. */
+  unbind(idServer: string, mxid: string, medium: string, address: string): Promise<boolean>;
+}
+//#endregion

package/dist/core/identity.js

@@ -0,0 +1,96 @@
+import { MatrixError } from "./errors.js";
+import { createHash } from "node:crypto";
+//#region src/core/identity.ts
+const urlSafe = (b) => b.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+var IdentityServers = class {
+	hs;
+	constructor(hs) {
+		this.hs = hs;
+	}
+	base(idServer) {
+		if (!/^[A-Za-z0-9.-]+(:\d+)?$/.test(idServer)) throw new MatrixError(400, "M_INVALID_PARAM", "Invalid id_server");
+		return `${this.hs.config.threepid.identityServerProtocol}://${idServer}`;
+	}
+	async call(idServer, method, path, opts = {}) {
+		const headers = { accept: "application/json" };
+		if (opts.body !== void 0) headers["content-type"] = "application/json";
+		if (opts.token) headers.authorization = `Bearer ${opts.token}`;
+		if (opts.signed) headers.authorization = this.hs.federation.client.authHeader(idServer, method, path, opts.body);
+		let res;
+		try {
+			res = await this.hs.fetch(`${this.base(idServer)}${path}`, {
+				method,
+				headers,
+				body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),
+				signal: AbortSignal.timeout(15e3)
+			});
+		} catch (err) {
+			throw new MatrixError(502, "M_UNKNOWN", `Identity server ${idServer} unreachable: ${err.message}`);
+		}
+		const json = await res.json().catch(() => ({}));
+		if (!res.ok) throw new MatrixError(res.status >= 500 ? 502 : res.status, typeof json.errcode === "string" ? json.errcode : "M_UNKNOWN", typeof json.error === "string" ? json.error : `Identity server returned ${res.status}`);
+		return json;
+	}
+	/** The Matrix user ID bound to a 3PID, if any. */
+	async lookup(idServer, token, medium, address) {
+		const details = await this.call(idServer, "GET", "/_matrix/identity/v2/hash_details", { token });
+		const algorithms = Array.isArray(details.algorithms) ? details.algorithms : [];
+		let query, algorithm;
+		if (algorithms.includes("sha256") && typeof details.lookup_pepper === "string") {
+			algorithm = "sha256";
+			query = urlSafe(createHash("sha256").update(`${address} ${medium} ${details.lookup_pepper}`).digest());
+		} else if (algorithms.includes("none")) {
+			algorithm = "none";
+			query = `${address} ${medium}`;
+		} else throw new MatrixError(400, "M_UNKNOWN", "The identity server supports no known lookup algorithm");
+		const mxid = (await this.call(idServer, "POST", "/_matrix/identity/v2/lookup", {
+			token,
+			body: {
+				addresses: [query],
+				algorithm,
+				pepper: details.lookup_pepper ?? ""
+			}
+		})).mappings?.[query];
+		return typeof mxid === "string" ? mxid : null;
+	}
+	async storeInvite(idServer, token, invite) {
+		const res = await this.call(idServer, "POST", "/_matrix/identity/v2/store-invite", {
+			token,
+			body: invite
+		});
+		if (typeof res.token !== "string" || !Array.isArray(res.public_keys)) throw new MatrixError(502, "M_UNKNOWN", "Invalid store-invite response");
+		return res;
+	}
+	/** Returns the identity server's record of the binding (medium, address, mxid...). */
+	async bind(idServer, token, sid, clientSecret, mxid) {
+		return this.call(idServer, "POST", "/_matrix/identity/v2/3pid/bind", {
+			token,
+			body: {
+				sid,
+				client_secret: clientSecret,
+				mxid
+			}
+		});
+	}
+	/** Remove a binding; resolves false when the identity server does not support unbinding. */
+	async unbind(idServer, mxid, medium, address) {
+		try {
+			await this.call(idServer, "POST", "/_matrix/identity/v2/3pid/unbind", {
+				signed: true,
+				body: {
+					mxid,
+					threepid: {
+						medium,
+						address
+					}
+				}
+			});
+			return true;
+		} catch (err) {
+			if (err instanceof MatrixError && (err.status === 404 || err.status === 501 || err.errcode === "M_UNRECOGNIZED")) return false;
+			throw err;
+		}
+	}
+};
+//#endregion
+export { IdentityServers };

package/dist/core/ids.js

@@ -0,0 +1,36 @@
+import { randomString } from "./crypto.js";
+//#region src/core/ids.ts
+const LOCALPART_RE = /^[a-z0-9._=\-/+]+$/;
+function parseId(id, sigil) {
+	if (typeof id !== "string" || !id.startsWith(sigil)) return null;
+	const idx = id.indexOf(":");
+	if (idx < 2) return null;
+	return {
+		localpart: id.slice(1, idx),
+		server: id.slice(idx + 1)
+	};
+}
+/** Server name grammar: DNS name, IPv4 or bracketed IPv6, with an optional port. */
+const SERVER_NAME_RE = /^(\[[0-9A-Fa-f:.]+\]|[A-Za-z0-9.-]+)(:\d{1,5})?$/;
+function isValidServerName(name) {
+	return name.length > 0 && name.length <= 255 && SERVER_NAME_RE.test(name);
+}
+function isValidUserId(id) {
+	if (typeof id !== "string" || id.length > 255) return false;
+	const parsed = parseId(id, "@");
+	return !!parsed && isValidServerName(parsed.server);
+}
+function isValidRoomId(id) {
+	return typeof id === "string" && /^![^\s:]+(:[^\s]+)?$/.test(id);
+}
+function isValidAlias(id) {
+	return typeof id === "string" && id.length <= 255 && !!parseId(id, "#");
+}
+function generateRoomId(serverName) {
+	return `!${randomString(18)}:${serverName}`;
+}
+function generateDeviceId() {
+	return randomString(10).toUpperCase();
+}
+//#endregion
+export { LOCALPART_RE, generateDeviceId, generateRoomId, isValidAlias, isValidRoomId, isValidServerName, isValidUserId, parseId };

package/dist/core/invitefilter.js

@@ -0,0 +1,36 @@
+import { isObject } from "./json.js";
+import { UNSTABLE } from "./m.js";
+import { globMatch } from "./glob.js";
+//#region src/core/invitefilter.ts
+const INVITE_CONFIG_TYPE = UNSTABLE.ORG.MATRIX.MSC4155.INVITE_PERMISSION_CONFIG;
+/**
+* MSC4155 invite filtering: "allow", "ignore" (accept but hide) or "block" (refuse).
+* User rules take precedence over server rules; within each, allow > ignore > block.
+*/
+async function inviteDecision(hs, target, inviter) {
+	const config = (await hs.db.findOne("account_data", [
+		{
+			field: "user_id",
+			value: target
+		},
+		{
+			field: "room_id",
+			value: ""
+		},
+		{
+			field: "type",
+			value: INVITE_CONFIG_TYPE
+		}
+	]))?.content;
+	if (!isObject(config)) return "allow";
+	const list = (k) => Array.isArray(config[k]) ? config[k].filter((x) => typeof x === "string") : [];
+	const server = inviter.slice(inviter.indexOf(":") + 1);
+	for (const [level, value] of [["users", inviter], ["servers", server]]) {
+		if (list(`allowed_${level}`).some((p) => globMatch(p, value))) return "allow";
+		if (list(`ignored_${level}`).some((p) => globMatch(p, value))) return "ignore";
+		if (list(`blocked_${level}`).some((p) => globMatch(p, value))) return "block";
+	}
+	return "allow";
+}
+//#endregion
+export { INVITE_CONFIG_TYPE, inviteDecision };

package/dist/core/json.js

@@ -0,0 +1,16 @@
+//#region src/core/json.ts
+/** Matrix canonical JSON: sorted keys, no whitespace, UTF-8, integers only. */
+function canonicalJson(value) {
+	if (value === null || typeof value !== "object") {
+		if (typeof value === "number" && !Number.isInteger(value)) throw new Error("Canonical JSON does not allow non-integer numbers");
+		return JSON.stringify(value ?? null);
+	}
+	if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+	const obj = value;
+	return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { canonicalJson, isObject };

package/dist/core/keys.d.ts

@@ -0,0 +1,36 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/core/keys.d.ts
+/** End-to-end encryption key storage (device keys, one-time keys, cross-signing). */
+export declare class KeyService {
+  private hs;
+  constructor(hs: Homeserver);
+  /** A local user's devices or device keys changed: update local clients and remote servers. */
+  deviceChanged(userId: string, deletedDeviceId?: string): Promise<void>;
+  markDeviceListChanged(userId: string, notify?: boolean): Promise<void>;
+  /**
+   * A partial-state room got its full state (MSC3902): device list updates received meanwhile for
+   * users we could not place count as changes now, if those users turned out to be members.
+   */
+  onPartialStateComplete(roomId: string, pendingUsers: string[]): Promise<void>;
+  upload(userId: string, deviceId: string, body: Record<string, any>): Promise<Record<string, number>>;
+  oneTimeKeyCounts(userId: string, deviceId: string): Promise<Record<string, number>>;
+  unusedFallbackKeyTypes(userId: string, deviceId: string): Promise<string[]>;
+  query(requester: string, deviceKeys: Record<string, string[]>, timeoutMs?: number): Promise<Record<string, any>>;
+  /** Whether a remote user shares a room with a local user (by known membership). */
+  isTracked(userId: string): Promise<boolean>;
+  dropRemoteCache(userId: string): Promise<void>;
+  /** A tracked user's device list changed: refetch it on the next query. */
+  markRemoteStale(userId: string): Promise<void>;
+  private storeRemoteCache;
+  private fromRemoteCache;
+  private withSignatures;
+  claim(request: Record<string, Record<string, string>>): Promise<Record<string, any>>;
+  uploadCrossSigning(userId: string, body: Record<string, any>): Promise<void>;
+  uploadSignatures(signer: string, body: Record<string, any>): Promise<Record<string, any>>;
+  /** Users (sharing a room with `userId`) whose device lists changed after `since`. */
+  changesSince(userId: string, since: number, upTo: number): Promise<{
+    changed: string[];
+    left: string[];
+  }>;
+}
+//#endregion