src/automod/Antiraid.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { Guild, GuildMember } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { GuildConfig } from "../types/GuildConfigSchema";
import { HasEventListeners } from "../types/HasEventListeners";
import { logError } from "../utils/logger";

export const name = "antiraid";

export default class Antiraid extends Service implements HasEventListeners {
    map: Map<string, { count: number; locked: boolean; timer?: NodeJS.Timeout }> = new Map();

    @GatewayEventListener("ready")
    async onReady() {
        for (const [id] of this.client.guilds.cache) this.map.set(id, { count: 0, locked: false });
    }

    @GatewayEventListener("guildMemberAdd")
    async onGuildMemberAdd(member: GuildMember) {
        if (member.user.bot) {
            return;
        }

        const config = this.client.configManager.config[member.guild.id]?.antiraid;

        if (!config?.enabled || !config.max_joins || !config.timeframe || config.timeframe < 6000) {
            return;
        }

        const info = this.map.get(member.guild.id) ?? { count: 0, locked: false };
        const { count, locked } = info;

        if (!locked && count > config.max_joins) {
            if (config.send_log)
                this.client.logger.logRaid({
                    guild: member.guild,
                    action:
                        config.action === "lock"
                            ? "Locked the server"
                            : config.action === "antijoin"
                            ? "Turned on anti join system"
                            : config.action === "lock_and_antijoin"
                            ? "Locked the server and turned on anti join system"
                            : config.action === "none"
                            ? "None"
                            : "Automatic"
                });

            this.map.set(member.guild.id, { count: count + 1, locked: true });

            if (config.action === "lock_and_antijoin") {
                await this.lock(member.guild, config);
                this.antijoin(member.guild);
            } else if (config.action === "antijoin" || config.action === "auto") {
                this.antijoin(member.guild);
            } else if (config.action === "lock") {
                await this.lock(member.guild, config);
            }
        } else if (!locked) {
            this.map.set(member.guild.id, { count: count + 1, locked });
        }

        if (!info.timer) {
            info.timer = setTimeout(() => {
                info.count = 0;
                this.map.set(member.guild.id, info);
                info.timer = undefined;
            }, config.timeframe);
        }
    }

    lock(guild: Guild, config: Exclude<GuildConfig["antiraid"], undefined>) {
        return this.client.channelLockManager
            .lockGuild(guild, {
                moderator: this.client.user!,
                channelMode: config.channel_mode,
                channels: config.channels,
                ignorePrivateChannels: config.ignore_private_channels,
                reason: "Possible raid detected"
            })
            .catch(logError);
    }

    antijoin(guild: Guild) {
        return this.client.antijoin.enable(guild);
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
5	*
6	* SudoBot is free software; you can redistribute it and/or modify it
7	* under the terms of the GNU Affero General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* SudoBot is distributed in the hope that it will be useful, but
12	* WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU Affero General Public License for more details.
15	*
16	* You should have received a copy of the GNU Affero General Public License
17	* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18	*/
19
20	import { Guild, GuildMember } from "discord.js";
21	import Service from "../core/Service";
22	import { GatewayEventListener } from "../decorators/GatewayEventListener";
23	import { GuildConfig } from "../types/GuildConfigSchema";
24	import { HasEventListeners } from "../types/HasEventListeners";
25	import { logError } from "../utils/logger";
26
27	export const name = "antiraid";
28
29	export default class Antiraid extends Service implements HasEventListeners {
30	map: Map<string, { count: number; locked: boolean; timer?: NodeJS.Timeout }> = new Map();
31
32	@GatewayEventListener("ready")
33	async onReady() {
34	for (const [id] of this.client.guilds.cache) this.map.set(id, { count: 0, locked: false });
35	}
36
37	@GatewayEventListener("guildMemberAdd")
38	async onGuildMemberAdd(member: GuildMember) {
39	if (member.user.bot) {
40	return;
41	}
42
43	const config = this.client.configManager.config[member.guild.id]?.antiraid;
44
45	if (!config?.enabled \|\| !config.max_joins \|\| !config.timeframe \|\| config.timeframe < 6000) {
46	return;
47	}
48
49	const info = this.map.get(member.guild.id) ?? { count: 0, locked: false };
50	const { count, locked } = info;
51
52	if (!locked && count > config.max_joins) {
53	if (config.send_log)
54	this.client.logger.logRaid({
55	guild: member.guild,
56	action:
57	config.action === "lock"
58	? "Locked the server"
59	: config.action === "antijoin"
60	? "Turned on anti join system"
61	: config.action === "lock_and_antijoin"
62	? "Locked the server and turned on anti join system"
63	: config.action === "none"
64	? "None"
65	: "Automatic"
66	});
67
68	this.map.set(member.guild.id, { count: count + 1, locked: true });
69
70	if (config.action === "lock_and_antijoin") {
71	await this.lock(member.guild, config);
72	this.antijoin(member.guild);
73	} else if (config.action === "antijoin" \|\| config.action === "auto") {
74	this.antijoin(member.guild);
75	} else if (config.action === "lock") {
76	await this.lock(member.guild, config);
77	}
78	} else if (!locked) {
79	this.map.set(member.guild.id, { count: count + 1, locked });
80	}
81
82	if (!info.timer) {
83	info.timer = setTimeout(() => {
84	info.count = 0;
85	this.map.set(member.guild.id, info);
86	info.timer = undefined;
87	}, config.timeframe);
88	}
89	}
90
91	lock(guild: Guild, config: Exclude<GuildConfig["antiraid"], undefined>) {
92	return this.client.channelLockManager
93	.lockGuild(guild, {
94	moderator: this.client.user!,
95	channelMode: config.channel_mode,
96	channels: config.channels,
97	ignorePrivateChannels: config.ignore_private_channels,
98	reason: "Possible raid detected"
99	})
100	.catch(logError);
101	}
102
103	antijoin(guild: Guild) {
104	return this.client.antijoin.enable(guild);
105	}
106	}