Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
6.4 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {getSsoRequestUrlPolicy} from '@app/api/instance/SsoConfigValidation';
import {Logger} from '@app/api/Logger';
import {EXTERNAL_RESPONSE_LIMITS} from '@app/api/utils/ExternalResponseLimits';
import * as FetchUtils from '@app/api/utils/FetchUtils';
import {parseJsonRecord} from '@app/api/utils/JsonBoundaryUtils';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {SsoProviderUnavailableError} from '@fluxer/errors/src/domains/auth/SsoProviderUnavailableError';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {formatUrlForDiagnostics} from '@pkgs/http_client/src/HttpClientDiagnostics';
import {HttpError, type HttpErrorType} from '@pkgs/http_client/src/HttpError';
import {ms} from 'itty-time';

export interface DiscoveredOidcProviderMetadata {
	issuer: string;
	authorization_endpoint?: string;
	token_endpoint?: string;
	userinfo_endpoint?: string;
	jwks_uri?: string;
	token_endpoint_auth_methods_supported?: Array<string>;
	id_token_signing_alg_values_supported?: Array<string>;
}

const PROVIDER_UNAVAILABLE_ERROR_TYPES = new Set<HttpErrorType>(['aborted', 'network_error', 'unresolvable_host']);

export async function sendProviderRequest(
	request: Parameters<typeof FetchUtils.sendRequest>[0],
): Promise<Awaited<ReturnType<typeof FetchUtils.sendRequest>>> {
	try {
		return await FetchUtils.sendRequest(request, {requestUrlPolicy: getSsoRequestUrlPolicy(), maxRedirects: 0});
	} catch (error) {
		Logger.warn({url: formatUrlForDiagnostics(request.url), error}, 'SSO provider request failed');
		if (error instanceof HttpError && error.errorType && PROVIDER_UNAVAILABLE_ERROR_TYPES.has(error.errorType)) {
			throw new SsoProviderUnavailableError();
		}
		throw InputValidationError.fromCode('sso', ValidationErrorCodes.SSO_MISCONFIGURED);
	}
}

const SSO_REDIRECT_BASE = 'https://sso-redirect.invalid';
const SSO_REDIRECT_MAX_LENGTH = 2048;
const SSO_REDIRECT_FORBIDDEN_CHARACTERS = /[\\\p{Cc}]/u;

export function sanitizeSsoRedirectTo(redirectTo?: string): string | undefined {
	const trimmed = redirectTo?.trim();
	if (!trimmed || trimmed.length > SSO_REDIRECT_MAX_LENGTH || !trimmed.startsWith('/')) return undefined;
	if (SSO_REDIRECT_FORBIDDEN_CHARACTERS.test(trimmed)) return undefined;
	const url = URL.parse(trimmed, SSO_REDIRECT_BASE);
	if (url?.origin !== SSO_REDIRECT_BASE) return undefined;
	const path = `${url.pathname}${url.search}${url.hash}`;
	return path.startsWith('//') || path.startsWith('/\\') ? undefined : path;
}

export function parseTokenEndpointResponse(
	contentTypeHeader: string | null,
	rawResponseBody: string,
): {
	id_token?: string;
	access_token?: string;
} {
	const contentType = contentTypeHeader?.toLowerCase() ?? '';
	const raw = rawResponseBody;
	if (contentType.includes('application/json')) {
		const parsed = parseJsonRecord(raw);
		if (!parsed) {
			return {id_token: undefined, access_token: undefined};
		}
		return {
			id_token: typeof parsed['id_token'] === 'string' ? parsed['id_token'] : undefined,
			access_token: typeof parsed['access_token'] === 'string' ? parsed['access_token'] : undefined,
		};
	}
	const params = new URLSearchParams(raw);
	return {
		id_token: params.get('id_token') ?? undefined,
		access_token: params.get('access_token') ?? undefined,
	};
}

function buildDiscoveryUrl(issuer: string): URL {
	const issuerUrl = URL.parse(issuer);
	if (!issuerUrl) {
		throw new Error('Invalid OIDC issuer URL');
	}
	const normalized = issuerUrl.toString().replace(/\/$/, '');
	return new URL(`${normalized}/.well-known/openid-configuration`);
}

function normalizeIssuerForCompare(value: string): string {
	return value.replace(/\/$/, '');
}

export function acceptedIssuers(issuer: string): Array<string> {
	const base = normalizeIssuerForCompare(issuer);
	return [base, `${base}/`];
}

function discoveryFailed(issuer: string, reason: string, details: Record<string, unknown> = {}): null {
	Logger.warn(
		{issuer: formatUrlForDiagnostics(issuer), reason, ...details},
		'Failed to discover OIDC provider metadata',
	);
	return null;
}

function readStringList(value: unknown): Array<string> | undefined {
	return Array.isArray(value) ? value.filter((item): item is string => typeof item === 'string') : undefined;
}

export async function tryDiscoverOidcProviderMetadata(issuer: string): Promise<DiscoveredOidcProviderMetadata | null> {
	try {
		const url = buildDiscoveryUrl(issuer);
		const resp = await FetchUtils.sendRequest(
			{
				url: url.toString(),
				method: 'GET',
				headers: {Accept: 'application/json'},
				timeout: ms('10 seconds'),
				serviceName: 'sso_oidc_discovery',
			},
			{requestUrlPolicy: getSsoRequestUrlPolicy(), maxRedirects: 0},
		);
		if (resp.status < 200 || resp.status >= 300) {
			FetchUtils.discardResponseBody(resp.stream, resp.status);
			return discoveryFailed(issuer, 'unexpected HTTP status', {status: resp.status});
		}
		const rawBody = await FetchUtils.streamToStringWithLimit(resp.stream, {
			maxBytes: EXTERNAL_RESPONSE_LIMITS.ssoDiscoveryBytes,
			headers: resp.headers,
			url: url.toString(),
			description: 'OIDC discovery response',
		});
		const json = parseJsonRecord(rawBody);
		if (!json) return discoveryFailed(issuer, 'response is not a JSON object');
		const discoveredIssuer = typeof json['issuer'] === 'string' ? json['issuer'] : null;
		if (!discoveredIssuer) return discoveryFailed(issuer, 'response has no issuer');
		if (normalizeIssuerForCompare(discoveredIssuer) !== normalizeIssuerForCompare(issuer)) {
			return discoveryFailed(issuer, 'response issuer does not match', {
				discovered_issuer: formatUrlForDiagnostics(discoveredIssuer),
			});
		}
		return {
			issuer: discoveredIssuer,
			authorization_endpoint:
				typeof json['authorization_endpoint'] === 'string' ? json['authorization_endpoint'] : undefined,
			token_endpoint: typeof json['token_endpoint'] === 'string' ? json['token_endpoint'] : undefined,
			userinfo_endpoint: typeof json['userinfo_endpoint'] === 'string' ? json['userinfo_endpoint'] : undefined,
			jwks_uri: typeof json['jwks_uri'] === 'string' ? json['jwks_uri'] : undefined,
			token_endpoint_auth_methods_supported: readStringList(json['token_endpoint_auth_methods_supported']),
			id_token_signing_alg_values_supported: readStringList(json['id_token_signing_alg_values_supported']),
		};
	} catch (error) {
		return discoveryFailed(issuer, 'request failed', {error});
	}
}