Skip to content

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

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

import type {IMediaService, MediaProxyMetadataResponse} from '@app/api/infrastructure/IMediaService';
import type {LimitConfigService} from '@app/api/limits/LimitConfigService';
import {createLimitMatchContext} from '@app/api/limits/LimitMatchContextBuilder';
import type {User} from '@app/api/models/User';
import {
	type AssetKind,
	formatAssetUploadExtensions,
	getPolicy,
	isExtensionAllowed,
} from '@fluxer/constants/src/AssetFormatPolicy';
import type {LimitKey} from '@fluxer/constants/src/LimitConfigMetadata';
import {ValidationErrorCodes} from '@fluxer/constants/src/ValidationErrorCodes';
import {InputValidationError} from '@fluxer/errors/src/domains/core/InputValidationError';
import {resolveLimit} from '@fluxer/limits/src/LimitResolver';

const EXPLICIT_IMAGERY_BLOCKED_KINDS: ReadonlySet<AssetKind> = new Set([
	'avatar',
	'banner',
	'guild_icon',
	'splash',
	'embed_splash',
	'role_icon',
	'sign_in_backdrop',
	'emoji',
	'sticker',
]);

export function resolveAssetSizeLimit(
	limitConfigService: Pick<LimitConfigService, 'getConfigSnapshot'>,
	key: LimitKey,
	fallback: number,
	guildFeatures: Iterable<string> | null = null,
	user: User | null = null,
): number {
	const ctx = createLimitMatchContext({user, guildFeatures});
	const resolved = resolveLimit(limitConfigService.getConfigSnapshot(), ctx, key, {
		evaluationContext: guildFeatures ? 'guild' : 'user',
	});
	if (!Number.isFinite(resolved) || resolved < 0) {
		return fallback;
	}
	return Math.floor(resolved);
}

export async function decodeValidatedImage(
	mediaService: IMediaService,
	params: {base64Image: string; errorPath: string; kind: AssetKind; maxSize: number},
): Promise<{imageBuffer: Uint8Array; metadata: MediaProxyMetadataResponse}> {
	const {base64Image, errorPath, kind, maxSize} = params;
	const base64Data = base64Image.includes(',') ? base64Image.split(',')[1] : base64Image;
	if (Buffer.byteLength(base64Data, 'base64') > maxSize) {
		throw InputValidationError.fromCode(errorPath, ValidationErrorCodes.IMAGE_SIZE_EXCEEDS_LIMIT, {maxSize});
	}
	const imageBuffer = new Uint8Array(Buffer.from(base64Data, 'base64'));
	const metadata = requireAllowedMetadata({
		metadata: await mediaService.getMetadata({
			type: 'base64',
			base64: base64Data,
			version: 2,
			nsfw: EXPLICIT_IMAGERY_BLOCKED_KINDS.has(kind) ? 'block' : 'allow',
		}),
		kind,
		errorPath,
	});
	return {imageBuffer, metadata};
}

function requireAllowedMetadata(params: {
	metadata: MediaProxyMetadataResponse | null;
	kind: AssetKind;
	errorPath: string;
}): MediaProxyMetadataResponse {
	const {metadata, kind, errorPath} = params;
	if (metadata == null || !isExtensionAllowed(kind, metadata.format)) {
		throwInvalidImageFormat(errorPath, kind);
	}
	const animated = metadata.animated ?? false;
	if (!animated) return metadata;
	if (getPolicy(kind).animated === 'never' || isAnimatedAvif(metadata)) {
		throwInvalidImageFormat(errorPath, kind);
	}
	return metadata;
}

function isAnimatedAvif(metadata: MediaProxyMetadataResponse): boolean {
	const format = metadata.format.toLowerCase();
	const contentType = metadata.content_type.toLowerCase();
	return format === 'avif' || contentType === 'image/avif' || contentType === 'image/avif-sequence';
}

function throwInvalidImageFormat(errorPath: string, kind: AssetKind): never {
	throw InputValidationError.fromCode(errorPath, ValidationErrorCodes.INVALID_IMAGE_FORMAT, {
		supportedExtensions: formatSupportedExtensions(kind),
	});
}

function formatSupportedExtensions(kind: AssetKind): string {
	return formatAssetUploadExtensions(kind, {labelStyle: 'extension'});
}