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	rakinar2	577	/**
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			}