Skip to content

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

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

import {createUserID, type UserID} from '@app/api/BrandedTypes';
import type {AuditLogChange, GuildAuditLogChange} from '@app/api/guild/GuildAuditLogTypes';
import {GuildAuditLog} from '@app/api/models/GuildAuditLog';
import {AuditLogActionType} from '@fluxer/constants/src/AuditLogActionType';
import {THREAD_FEATURE_CHANNEL_TYPES} from '@fluxer/constants/src/ThreadConstants';
import {THREAD_PERMISSIONS, ThreadPermissionFlags} from '@fluxer/constants/src/ThreadPermissionUtils';
import type {AuditLogOptions, GuildAuditLogEntryResponse} from '@fluxer/schema/src/domains/guild/GuildAuditLogSchemas';
import {isValidSnowflake} from '@fluxer/snowflake/src/Snowflake';

export interface StoredGuildAuditLogEntryResponse extends Omit<GuildAuditLogEntryResponse, 'changes'> {
	changes?: GuildAuditLogChange;
}

type NumericAuditLogOptionKey =
	| 'count'
	| 'delete_message_seconds'
	| 'integration_type'
	| 'members_removed'
	| 'type'
	| 'max_age'
	| 'max_uses'
	| 'uses';

const GUILD_AUDIT_INTERNAL_CHANGE_KEYS: ReadonlySet<string> = new Set([
	'guild_id',
	'member_count',
	'banner_width',
	'banner_height',
	'splash_width',
	'splash_height',
	'embed_splash_width',
	'embed_splash_height',
]);

const NOOP_SKIPPABLE_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.GUILD_UPDATE,
	AuditLogActionType.CHANNEL_UPDATE,
	AuditLogActionType.CHANNEL_OVERWRITE_UPDATE,
	AuditLogActionType.MEMBER_UPDATE,
	AuditLogActionType.MEMBER_ROLE_UPDATE,
	AuditLogActionType.MEMBER_MOVE,
	AuditLogActionType.ROLE_UPDATE,
	AuditLogActionType.WEBHOOK_UPDATE,
	AuditLogActionType.EMOJI_UPDATE,
	AuditLogActionType.STICKER_UPDATE,
]);

const USER_TARGET_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.MEMBER_KICK,
	AuditLogActionType.MEMBER_PRUNE,
	AuditLogActionType.MEMBER_BAN_ADD,
	AuditLogActionType.MEMBER_BAN_REMOVE,
	AuditLogActionType.MEMBER_UPDATE,
	AuditLogActionType.MEMBER_ROLE_UPDATE,
	AuditLogActionType.MEMBER_MOVE,
	AuditLogActionType.MEMBER_DISCONNECT,
	AuditLogActionType.BOT_ADD,
]);

const CREATOR_CHANGE_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.WEBHOOK_DELETE,
	AuditLogActionType.EMOJI_DELETE,
	AuditLogActionType.STICKER_DELETE,
]);

const OVERWRITE_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.CHANNEL_OVERWRITE_CREATE,
	AuditLogActionType.CHANNEL_OVERWRITE_UPDATE,
	AuditLogActionType.CHANNEL_OVERWRITE_DELETE,
]);

export const THREAD_SCOPED_AUDIT_OPTION = 'thread_scoped';

export const THREAD_AUDIT_LOG_ACTION_TYPES: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.THREAD_CREATE,
	AuditLogActionType.THREAD_UPDATE,
	AuditLogActionType.THREAD_DELETE,
]);

const CHANNEL_TARGET_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.CHANNEL_CREATE,
	AuditLogActionType.CHANNEL_UPDATE,
	AuditLogActionType.CHANNEL_DELETE,
	...OVERWRITE_ACTIONS,
]);

const THREAD_FEATURE_CHANNEL_TYPE_STRINGS: ReadonlySet<string> = new Set(
	[...THREAD_FEATURE_CHANNEL_TYPES].map((type) => type.toString()),
);

export function collectAuditLogChannelIds(log: GuildAuditLog): Array<string> {
	const ids: Array<string> = [];
	if (CHANNEL_TARGET_ACTIONS.has(log.actionType) && log.targetId) ids.push(log.targetId);
	const channelId = log.options.get('channel_id');
	if (channelId) ids.push(channelId);
	return ids;
}

export function isThreadScopedAuditLog(log: GuildAuditLog, gatedChannelIds: ReadonlySet<string>): boolean {
	if (THREAD_AUDIT_LOG_ACTION_TYPES.has(log.actionType) || log.options.has(THREAD_SCOPED_AUDIT_OPTION)) return true;
	if (
		(log.actionType === AuditLogActionType.CHANNEL_CREATE ||
			log.actionType === AuditLogActionType.CHANNEL_UPDATE ||
			log.actionType === AuditLogActionType.CHANNEL_DELETE) &&
		THREAD_FEATURE_CHANNEL_TYPE_STRINGS.has(log.options.get('type') ?? '')
	) {
		return true;
	}
	return collectAuditLogChannelIds(log).some((id) => gatedChannelIds.has(id));
}

const THREAD_PERMISSION_CHANGE_KEYS: ReadonlyMap<AuditLogActionType, ReadonlySet<string>> = new Map([
	[AuditLogActionType.ROLE_CREATE, new Set(['permissions'])],
	[AuditLogActionType.ROLE_UPDATE, new Set(['permissions', 'permissions_diff'])],
	[AuditLogActionType.ROLE_DELETE, new Set(['permissions'])],
	...[...OVERWRITE_ACTIONS].map((action) => [action, new Set(['allow', 'deny'])] as const),
]);

const THREAD_SURFACE_CHANGE_KEYS: ReadonlySet<string> = new Set([
	'thread_metadata',
	'applied_tags',
	'available_tags',
	'default_auto_archive_duration',
	'default_thread_rate_limit_per_user',
	'default_reaction_emoji',
	'default_sort_order',
	'default_forum_layout',
	'default_tag_setting',
	'message_count',
	'total_message_sent',
	'member_ids_preview',
	'member_count',
	'flags',
]);

const CHANNEL_ACTIONS: ReadonlySet<AuditLogActionType> = new Set([
	AuditLogActionType.CHANNEL_CREATE,
	AuditLogActionType.CHANNEL_UPDATE,
	AuditLogActionType.CHANNEL_DELETE,
]);

const THREAD_PERMISSION_NAMES: ReadonlySet<string> = new Set(Object.keys(ThreadPermissionFlags));

function stripThreadBitsValue(value: unknown): unknown {
	if (typeof value === 'string' && /^\d{1,20}$/.test(value)) return (BigInt(value) & ~THREAD_PERMISSIONS).toString();
	if (!isPermissionsDiff(value)) return value;
	const added = value.added.filter((name) => !THREAD_PERMISSION_NAMES.has(name));
	const removed = value.removed.filter((name) => !THREAD_PERMISSION_NAMES.has(name));
	if (added.length === value.added.length && removed.length === value.removed.length) return value;
	return added.length > 0 || removed.length > 0 ? {added, removed} : undefined;
}

function isPermissionsDiff(value: unknown): value is {added: Array<string>; removed: Array<string>} {
	return (
		typeof value === 'object' &&
		value !== null &&
		Array.isArray((value as {added?: unknown}).added) &&
		Array.isArray((value as {removed?: unknown}).removed)
	);
}

export function maskThreadAuditLog(log: GuildAuditLog): GuildAuditLog {
	if (!log.changes) return log;
	const permissionKeys = THREAD_PERMISSION_CHANGE_KEYS.get(log.actionType);
	const surfaceKeys = CHANNEL_ACTIONS.has(log.actionType) ? THREAD_SURFACE_CHANGE_KEYS : null;
	if (!permissionKeys && !surfaceKeys) return log;
	let changed = false;
	const masked: GuildAuditLogChange = [];
	for (const change of log.changes) {
		if (surfaceKeys?.has(change.key)) {
			changed = true;
			continue;
		}
		if (!permissionKeys?.has(change.key)) {
			masked.push(change);
			continue;
		}
		const next: AuditLogChange = {key: change.key};
		if ('old_value' in change) next.old_value = stripThreadBitsValue(change.old_value);
		if ('new_value' in change) next.new_value = stripThreadBitsValue(change.new_value);
		changed ||= next.old_value !== change.old_value || next.new_value !== change.new_value;
		if (next.old_value === next.new_value) {
			changed = true;
			continue;
		}
		masked.push(next);
	}
	if (!changed) return log;
	return new GuildAuditLog({...log.toRow(), changes: masked.length > 0 ? JSON.stringify(masked) : null});
}

const SNOWFLAKE_PATTERN = /^\d{1,20}$/;

export function isNoopGuildAuditLog(
	actionType: AuditLogActionType,
	changes: GuildAuditLogChange | null | undefined,
): boolean {
	if (!NOOP_SKIPPABLE_ACTIONS.has(actionType)) {
		return false;
	}
	if (!changes) {
		return true;
	}
	return !changes.some(
		(change) =>
			change.key !== 'ip' &&
			!(actionType === AuditLogActionType.GUILD_UPDATE && GUILD_AUDIT_INTERNAL_CHANGE_KEYS.has(change.key)),
	);
}

export function mapGuildAuditLogEntry(log: GuildAuditLog): StoredGuildAuditLogEntryResponse {
	return {
		id: log.logId.toString(),
		action_type: log.actionType as GuildAuditLogEntryResponse['action_type'],
		user_id: log.userId.toString(),
		target_id: log.targetId,
		reason: resolveEntryReason(log),
		options: buildAuditLogOptions(log.options),
		changes: scrubSensitiveChanges(log.changes),
	};
}

export function collectGuildAuditLogUserIds(log: GuildAuditLog): Array<UserID> {
	const userIds = new Set<UserID>([log.userId]);
	const addUserId = (value: unknown) => {
		const userId = parseUserId(value);
		if (userId !== null) {
			userIds.add(userId);
		}
	};
	if (USER_TARGET_ACTIONS.has(log.actionType)) {
		addUserId(log.targetId);
	}
	if (log.actionType === AuditLogActionType.GUILD_UPDATE) {
		addUserId(findChange(log.changes, 'owner_id')?.new_value);
	}
	if (log.actionType === AuditLogActionType.MEMBER_BAN_REMOVE) {
		addUserId(findChange(log.changes, 'moderator_id')?.old_value);
	}
	if (log.actionType === AuditLogActionType.INVITE_DELETE) {
		addUserId(log.options.get('inviter_id'));
	}
	if (CREATOR_CHANGE_ACTIONS.has(log.actionType)) {
		addUserId(findChange(log.changes, 'creator_id')?.old_value);
	}
	if (OVERWRITE_ACTIONS.has(log.actionType) && log.options.get('type') === '1') {
		addUserId(log.targetId);
	}
	return Array.from(userIds);
}

function resolveEntryReason(log: GuildAuditLog): string | undefined {
	const explicitReason = readNonBlankString(log.reason);
	if (explicitReason !== null) {
		return explicitReason;
	}
	if (log.actionType === AuditLogActionType.MEMBER_BAN_ADD) {
		return readNonBlankString(findChange(log.changes, 'reason')?.new_value) ?? undefined;
	}
	if (log.actionType === AuditLogActionType.MEMBER_UPDATE) {
		return readNonBlankString(log.options.get('timeout_reason')) ?? undefined;
	}
	return undefined;
}

function readNonBlankString(value: unknown): string | null {
	if (typeof value !== 'string') {
		return null;
	}
	const trimmed = value.trim();
	return trimmed.length > 0 ? trimmed : null;
}

function findChange(changes: GuildAuditLogChange | null, key: string): AuditLogChange | undefined {
	return changes?.find((change) => change.key === key);
}

function scrubSensitiveChanges(changes: GuildAuditLogChange | null | undefined): GuildAuditLogChange | undefined {
	if (!changes) {
		return undefined;
	}
	const scrubbed = changes.filter((change) => change.key !== 'ip');
	return scrubbed.length > 0 ? scrubbed : undefined;
}

function buildAuditLogOptions(options: Map<string, string>): AuditLogOptions | undefined {
	if (!options.size) {
		return undefined;
	}
	const mapped: AuditLogOptions = {};
	for (const [key, value] of options) {
		switch (key) {
			case 'channel_id':
				mapped.channel_id = value;
				break;
			case 'count':
				assignNumericOption(mapped, 'count', value);
				break;
			case 'delete_member_days':
				mapped.delete_member_days = value;
				break;
			case 'delete_message_days':
				if (!mapped.delete_member_days) {
					mapped.delete_member_days = value;
				}
				break;
			case 'delete_message_seconds':
				assignNumericOption(mapped, 'delete_message_seconds', value);
				break;
			case 'id':
				mapped.id = value;
				break;
			case 'integration_type':
				assignNumericOption(mapped, 'integration_type', value);
				break;
			case 'message_id':
				mapped.message_id = value;
				break;
			case 'members_removed':
				assignNumericOption(mapped, 'members_removed', value);
				break;
			case 'role_name':
				mapped.role_name = value;
				break;
			case 'type':
				assignNumericOption(mapped, 'type', value);
				break;
			case 'inviter_id':
				mapped.inviter_id = value;
				break;
			case 'max_age':
				assignNumericOption(mapped, 'max_age', value);
				break;
			case 'max_uses':
				assignNumericOption(mapped, 'max_uses', value);
				break;
			case 'uses':
				assignNumericOption(mapped, 'uses', value);
				break;
			case 'temporary':
				mapped.temporary = parseBooleanOption(value);
				break;
			default:
				break;
		}
	}
	return Object.keys(mapped).length === 0 ? undefined : mapped;
}

function parseBooleanOption(value: string): boolean {
	return value === 'true' || value === '1';
}

function assignNumericOption(target: AuditLogOptions, key: NumericAuditLogOptionKey, value: string): void {
	const parsed = Number(value);
	if (!Number.isNaN(parsed)) {
		target[key] = parsed;
	}
}

function parseUserId(value: unknown): UserID | null {
	if (typeof value !== 'string' || !SNOWFLAKE_PATTERN.test(value)) {
		return null;
	}
	const id = BigInt(value);
	return isValidSnowflake(id) ? createUserID(id) : null;
}