3
0
Fork 0
mirror of https://github.com/ZeppelinBot/Zeppelin.git synced 2025-03-16 06:11:49 +00:00
zeppelin/src/plugins/Censor.ts

262 lines
8.1 KiB
TypeScript
Raw Normal View History

import { IPluginOptions } from "knub";
import { Invite } from "eris";
import escapeStringRegexp from "escape-string-regexp";
import { GuildLogs } from "../data/GuildLogs";
import { LogType } from "../data/LogType";
import {
deactivateMentions,
disableCodeBlocks,
getInviteCodesInString,
getUrlsInString,
stripObjectToScalars,
} from "../utils";
2018-08-02 22:24:54 +03:00
import { ZalgoRegex } from "../data/Zalgo";
import { GuildSavedMessages } from "../data/GuildSavedMessages";
import { SavedMessage } from "../data/entities/SavedMessage";
import { ZeppelinPlugin } from "./ZeppelinPlugin";
interface ICensorPluginConfig {
filter_zalgo: boolean;
filter_invites: boolean;
invite_guild_whitelist: string[];
invite_guild_blacklist: string[];
invite_code_whitelist: string[];
invite_code_blacklist: string[];
allow_group_dm_invites: boolean;
filter_domains: boolean;
domain_whitelist: string[];
domain_blacklist: string[];
blocked_tokens: string[];
blocked_words: string[];
blocked_regex: string[];
}
export class CensorPlugin extends ZeppelinPlugin<ICensorPluginConfig> {
public static pluginName = "censor";
protected serverLogs: GuildLogs;
protected savedMessages: GuildSavedMessages;
private onMessageCreateFn;
private onMessageUpdateFn;
getDefaultOptions(): IPluginOptions<ICensorPluginConfig> {
return {
config: {
2018-08-02 22:24:54 +03:00
filter_zalgo: false,
filter_invites: false,
invite_guild_whitelist: null,
invite_guild_blacklist: null,
invite_code_whitelist: null,
invite_code_blacklist: null,
allow_group_dm_invites: false,
filter_domains: false,
domain_whitelist: null,
domain_blacklist: null,
blocked_tokens: null,
blocked_words: null,
blocked_regex: null,
},
overrides: [
{
level: ">=50",
config: {
2018-08-02 22:24:54 +03:00
filter_zalgo: false,
filter_invites: false,
filter_domains: false,
blocked_tokens: null,
blocked_words: null,
blocked_regex: null,
},
},
],
};
}
onLoad() {
this.serverLogs = new GuildLogs(this.guildId);
this.savedMessages = GuildSavedMessages.getInstance(this.guildId);
this.onMessageCreateFn = this.onMessageCreate.bind(this);
this.onMessageUpdateFn = this.onMessageUpdate.bind(this);
this.savedMessages.events.on("create", this.onMessageCreateFn);
this.savedMessages.events.on("update", this.onMessageUpdateFn);
}
onUnload() {
this.savedMessages.events.off("create", this.onMessageCreateFn);
this.savedMessages.events.off("update", this.onMessageUpdateFn);
}
async censorMessage(savedMessage: SavedMessage, reason: string) {
this.serverLogs.ignoreLog(LogType.MESSAGE_DELETE, savedMessage.id);
try {
await this.bot.deleteMessage(savedMessage.channel_id, savedMessage.id, "Censored");
} catch (e) {
return;
}
const member = this.guild.members.get(savedMessage.user_id);
const channel = this.guild.channels.get(savedMessage.channel_id);
this.serverLogs.log(LogType.CENSOR, {
member: stripObjectToScalars(member, ["user"]),
channel: stripObjectToScalars(channel),
reason,
messageText: disableCodeBlocks(deactivateMentions(savedMessage.data.content)),
});
}
/**
* Applies word censor filters to the message, if any apply.
* @return {boolean} Indicates whether the message was removed
*/
async applyFiltersToMsg(savedMessage: SavedMessage): Promise<boolean> {
if (!savedMessage.data.content) return false;
const config = this.getConfigForMemberIdAndChannelId(savedMessage.user_id, savedMessage.channel_id);
2018-08-02 22:24:54 +03:00
// Filter zalgo
const filterZalgo = config.filter_zalgo;
if (filterZalgo) {
const result = ZalgoRegex.exec(savedMessage.data.content);
2018-08-02 22:24:54 +03:00
if (result) {
this.censorMessage(savedMessage, "zalgo detected");
return true;
2018-08-02 22:24:54 +03:00
}
}
// Filter invites
const filterInvites = config.filter_invites;
if (filterInvites) {
const inviteGuildWhitelist = config.invite_guild_whitelist;
const inviteGuildBlacklist = config.invite_guild_blacklist;
const inviteCodeWhitelist = config.invite_code_whitelist;
const inviteCodeBlacklist = config.invite_code_blacklist;
const allowGroupDMInvites = config.allow_group_dm_invites;
const inviteCodes = getInviteCodesInString(savedMessage.data.content);
let invites: Invite[] = await Promise.all(inviteCodes.map(code => this.bot.getInvite(code).catch(() => null)));
invites = invites.filter(v => !!v);
for (const invite of invites) {
if (!invite.guild && !allowGroupDMInvites) {
this.censorMessage(savedMessage, `group dm invites are not allowed`);
return true;
}
if (inviteGuildWhitelist && !inviteGuildWhitelist.includes(invite.guild.id)) {
this.censorMessage(
savedMessage,
`invite guild (**${invite.guild.name}** \`${invite.guild.id}\`) not found in whitelist`,
);
return true;
}
if (inviteGuildBlacklist && inviteGuildBlacklist.includes(invite.guild.id)) {
this.censorMessage(
savedMessage,
`invite guild (**${invite.guild.name}** \`${invite.guild.id}\`) found in blacklist`,
);
return true;
}
if (inviteCodeWhitelist && !inviteCodeWhitelist.includes(invite.code)) {
this.censorMessage(savedMessage, `invite code (\`${invite.code}\`) not found in whitelist`);
return true;
}
if (inviteCodeBlacklist && inviteCodeBlacklist.includes(invite.code)) {
this.censorMessage(savedMessage, `invite code (\`${invite.code}\`) found in blacklist`);
return true;
}
}
}
// Filter domains
const filterDomains = config.filter_domains;
if (filterDomains) {
const domainWhitelist = config.domain_whitelist;
const domainBlacklist = config.domain_blacklist;
const urls = getUrlsInString(savedMessage.data.content);
for (const thisUrl of urls) {
if (domainWhitelist && !domainWhitelist.includes(thisUrl.hostname)) {
this.censorMessage(savedMessage, `domain (\`${thisUrl.hostname}\`) not found in whitelist`);
return true;
}
if (domainBlacklist && domainBlacklist.includes(thisUrl.hostname)) {
this.censorMessage(savedMessage, `domain (\`${thisUrl.hostname}\`) found in blacklist`);
return true;
}
}
}
// Filter tokens
const blockedTokens = config.blocked_tokens || [];
for (const token of blockedTokens) {
if (savedMessage.data.content.toLowerCase().includes(token.toLowerCase())) {
this.censorMessage(savedMessage, `blocked token (\`${token}\`) found`);
return true;
}
}
// Filter words
const blockedWords = config.blocked_words || [];
for (const word of blockedWords) {
const regex = new RegExp(`\\b${escapeStringRegexp(word)}\\b`, "i");
if (regex.test(savedMessage.data.content)) {
this.censorMessage(savedMessage, `blocked word (\`${word}\`) found`);
return true;
}
}
// Filter regex
const blockedRegex = config.blocked_regex || [];
for (const regexStr of blockedRegex) {
const regex = new RegExp(regexStr, "i");
if (regex.test(savedMessage.data.content)) {
this.censorMessage(savedMessage, `blocked regex (\`${regexStr}\`) found`);
return true;
}
}
return false;
}
async onMessageCreate(savedMessage: SavedMessage) {
2018-12-14 09:14:13 +02:00
if (savedMessage.is_bot) return;
const lock = await this.locks.acquire(`message-${savedMessage.id}`);
const wasDeleted = await this.applyFiltersToMsg(savedMessage);
if (wasDeleted) {
lock.interrupt();
} else {
lock.unlock();
}
}
async onMessageUpdate(savedMessage: SavedMessage) {
2018-12-14 09:14:13 +02:00
if (savedMessage.is_bot) return;
const lock = await this.locks.acquire(`message-${savedMessage.id}`);
const wasDeleted = await this.applyFiltersToMsg(savedMessage);
if (wasDeleted) {
lock.interrupt();
} else {
lock.unlock();
}
}
}