494 lines
20 KiB
JavaScript
494 lines
20 KiB
JavaScript
const { inspect } = require('util');
|
|
const similarity = require('similarity');
|
|
const { stripIndents } = require('common-tags');
|
|
|
|
const { Observer, BinaryTree } = require('../../../interfaces');
|
|
const { FilterUtil, FilterPresets, Util } = require('../../../../util');
|
|
const { Warn, Mute, Kick, Softban, Ban } = require('../../../moderation/infractions');
|
|
|
|
const CONSTANTS = {
|
|
Infractions: {
|
|
WARN: Warn,
|
|
MUTE: Mute,
|
|
KICK: Kick,
|
|
SOFTBAN: Softban,
|
|
BAN: Ban
|
|
}
|
|
};
|
|
|
|
// TODO:
|
|
// Clean up commented out code once testing of new code is done
|
|
// Implement missing automod features
|
|
|
|
|
|
module.exports = class AutoModeration extends Observer {
|
|
|
|
constructor(client) {
|
|
|
|
super(client, {
|
|
name: 'autoModeration',
|
|
priority: 1,
|
|
disabled: false
|
|
});
|
|
|
|
this.hooks = [
|
|
['message', this.filterWords.bind(this)],
|
|
['messageUpdate', this.filterWords.bind(this)],
|
|
['message', this.flagMessages.bind(this)],
|
|
['messageUpdate', this.flagMessages.bind(this)],
|
|
['message', this.filterLinks.bind(this)],
|
|
['messageUpdate', this.filterLinks.bind(this)],
|
|
['message', this.filterInvites.bind(this)],
|
|
['messageUpdate', this.filterInvites.bind(this)],
|
|
['message', this.filterMentions.bind(this)]
|
|
];
|
|
|
|
this.whitelist = new BinaryTree(this.client, FilterPresets.whitelist);
|
|
|
|
}
|
|
|
|
_moderate(action, guild, channel, member, moderationPoints, silent, reason, filterResult, message) {
|
|
this.client.moderationManager.autoModerate({ guild, action, message, reason, silent, data: { filterResult } });
|
|
|
|
/* this.client.moderationManager.handleInfraction(
|
|
CONSTANTS.Infractions[action.type],
|
|
{ // Hacky patched together message object with just the required stuff for modmanager to work
|
|
guild,
|
|
member: guild.me,
|
|
channel,
|
|
arguments: {
|
|
force: {
|
|
value: action.force
|
|
},
|
|
points: {
|
|
value: action.points || moderationPoints.points[action.type]
|
|
},
|
|
expiration: {
|
|
value: action.expiration || moderationPoints.expirations[action.type]
|
|
},
|
|
silent
|
|
},
|
|
format: guild.format.bind(guild),
|
|
// eslint-disable-next-line no-empty-function
|
|
respond: () => { }
|
|
},
|
|
{
|
|
targets: [member],
|
|
reason,
|
|
duration: action.duration,
|
|
data: {
|
|
filterResult
|
|
}
|
|
}
|
|
);*/
|
|
}
|
|
|
|
async filterWords(message, edited) {
|
|
|
|
const { guild, author, channel, command } = message;
|
|
if (!guild || author.bot) return;
|
|
|
|
const member = message.member || await guild.members.fetch(author.id).catch();
|
|
const settings = await guild.settings();
|
|
const { wordFilter: setting, moderationPoints } = settings;
|
|
const { bypass, ignore, enabled, silent, explicit, fuzzy, regex, whitelist, actions } = setting;
|
|
const roles = member?.roles.cache.map((r) => r.id) || [];
|
|
|
|
if (!enabled || roles.some((r) => bypass.includes(r)) || ignore.includes(channel.id)) return;
|
|
|
|
if (command?.name === 'settings') {
|
|
// NOTE: probably needs a more permanent solution
|
|
const result = await this.client.registry.components.get('observer:permissions').execute(message, message.command);
|
|
if (!result.error) return;
|
|
}
|
|
|
|
// Which message obj to work with
|
|
const msg = edited || message;
|
|
if (!msg.content) return;
|
|
let log = `Message filter debug:`;
|
|
log += `\nPre norm: ${msg.cleanContent}`;
|
|
let content = null;
|
|
try { // NOTE: Remove try-catch after debug
|
|
content = FilterUtil.normalise(Util.removeMarkdown(msg.cleanContent));
|
|
} catch (err) {
|
|
this.client.logger.debug(log);
|
|
return;
|
|
}
|
|
log += `\nNormalised: ${content}`;
|
|
|
|
const catcher = (ln) => {
|
|
return () => this.client.logger.debug(`Issue with promise on line ${ln}`);
|
|
};
|
|
|
|
// match: what was matched |
|
|
// matched: did it match at all ? |
|
|
// matcher: what gets shown in the message logs |
|
|
// _matcher: locally used variable for which word in the list triggered it |
|
|
// type: which detection type matched it
|
|
let filterResult = { match: null, matched: false, matcher: null, _matcher: null, preset: false };
|
|
const words = content.toLowerCase().split(' ').filter((elem) => elem.length);
|
|
// Remove any potential bypass characters
|
|
//const _words = words.map((word) => word.replace(/[.'*_?+"#%&=-]/gu, ''));
|
|
|
|
// 1. Filter for preset lists
|
|
// CHANGED BEHAVIOUR OF PRESETS, THEY NOW USE THE REGEX PART OF THE FILTER
|
|
// if (presets.length) {
|
|
// for (const preset of presets) {
|
|
|
|
// const text = _words.join('').replace(/\s/u, ''); //Also check for spaced out words, ex "f u c k"
|
|
// //Combine array of presets to one expression
|
|
// const _regex = new RegExp(`(${FilterPresets[preset].join(')|(')})`, 'ui');
|
|
// const match = content.match(_regex) || text.length === words.length ? text.match(_regex) : null;
|
|
// if (!match) continue;
|
|
// this.client.logger.debug(`\nMessage matched with "${preset}" preset list.\nMatch: ${match[0]}\nFull content: ${content}`);
|
|
// filterResult = {
|
|
// match: match[0],
|
|
// matched: true,
|
|
// matcher: preset,
|
|
// preset,
|
|
// type: 'preset'
|
|
// };
|
|
// break;
|
|
|
|
// }
|
|
// }
|
|
|
|
// 2. Filter explicit - no bypass checking (unless you count normalising the text, i.e. emoji letters => normal letters)
|
|
if (explicit.length && !filterResult.matched) {
|
|
|
|
//filterResult = FilterUtil.filterExplicit(words, explicit);
|
|
// if(filterResult)
|
|
|
|
for (const word of explicit) {
|
|
//Do it like this instead of regex so it doesn't match stuff like Scunthorpe with cunt
|
|
if (words.some((_word) => _word === word)) {
|
|
log += `\nMessage matched with "${word}" in the explicit list.\nFull content: ${content}`;
|
|
filterResult = {
|
|
match: word,
|
|
matched: true,
|
|
matcher: 'explicit',
|
|
_matcher: word,
|
|
type: 'explicit'
|
|
};
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 3. Filter regex
|
|
if (regex.length && !filterResult.matched) {
|
|
|
|
for (const reg of regex) {
|
|
|
|
const match = content.match(new RegExp(reg, 'iu'));
|
|
|
|
if (match) {
|
|
log += `\nMessage matched with "${reg}" in the regex list.\nMatch: ${match[0]}\nFull content: ${content}`;
|
|
filterResult = {
|
|
match: match[0],
|
|
matched: true,
|
|
_matcher: match[0].toLowerCase(),
|
|
matcher: `Regex: __${reg}__`,
|
|
type: 'regex'
|
|
};
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 4. Filter fuzzy
|
|
if (fuzzy.length && !filterResult.matched) {
|
|
|
|
const text = words.join('').replace(/\s/u, '');
|
|
const threshold = 0.93 - 0.165 * Math.log(text.length);
|
|
|
|
outer:
|
|
for (const _word of fuzzy) {
|
|
|
|
for (const word of words) {
|
|
const sim = similarity(word, _word);
|
|
const threshold = 0.93 - 0.165 * Math.log(word.length);
|
|
if (sim >= threshold && Math.abs(_word.length - word.length) < 3) {
|
|
if (this.whitelist.find(word) || whitelist.some((w) => w === word) && sim < 1) continue;
|
|
log += `\nMessage matched with "${_word}" in fuzzy.\nMatched word: ${word}\nFull content: ${content}\nSimilarity: ${sim}\nThreshold: ${threshold}`;
|
|
filterResult = {
|
|
match: word,
|
|
matched: true,
|
|
_matcher: _word,
|
|
matcher: `fuzzy [\`${_word}\`, \`${sim}\`, \`${threshold}\`]`,
|
|
type: 'fuzzy'
|
|
};
|
|
break outer;
|
|
}
|
|
|
|
}
|
|
|
|
const sim = similarity(text, _word);
|
|
if (sim >= threshold && Math.abs(_word.length - text.length) < 3) {
|
|
if (this.whitelist.find(text) || whitelist.some((w) => w === text) && sim < 1) continue;
|
|
log += `\nMessage matched with "${_word}" in fuzzy.\nMatched word: ${text}\nFull content: ${content}\nSimilarity: ${sim}\nThreshold: ${threshold}`;
|
|
filterResult = {
|
|
match: text,
|
|
matched: true,
|
|
_matcher: _word,
|
|
matcher: `fuzzy [\`${_word}\`, \`${sim}\`, \`${threshold}\`]`,
|
|
type: 'fuzzy'
|
|
};
|
|
break;
|
|
}
|
|
|
|
//this.client.logger.debug(`Message did not match with "${_word}" in fuzzy.\nFull content: ${content}\nSimilarity: ${sim}\nThreshold: ${threshold}`);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 5. Remove message, inline response and add a reason to msg object
|
|
if (!filterResult.matched) return;
|
|
msg.filtered = filterResult;
|
|
log += `\nFilter result: ${inspect(filterResult)}`;
|
|
if (!silent) {
|
|
const res = await this.client.rateLimiter.limitSend(msg.channel, msg.format('W_FILTER_DELETE', { user: author.id }), undefined, 'wordFilter').catch(catcher(255));
|
|
//const res = await msg.formattedRespond('W_FILTER_DELETE', { params: { user: author.id } });
|
|
if (res) res.delete({ timeout: 10000 }).catch(catcher(257));
|
|
}
|
|
|
|
// 6. Automated actions
|
|
if (actions.length) {
|
|
|
|
let action = actions.find((act) => {
|
|
return act.trigger.includes(filterResult._matcher);
|
|
});
|
|
if (!action) action = actions.find((act) => {
|
|
return act.trigger === filterResult.type;
|
|
});
|
|
if (!action) action = actions.find((act) => {
|
|
return act.trigger === 'generic';
|
|
});
|
|
|
|
if (!action) {
|
|
this.client.logger.debug(log);
|
|
this.client.rateLimiter.queueDelete(msg.channel, msg).catch(catcher(275));
|
|
}
|
|
|
|
msg.filtered.sanctioned = true;
|
|
this.client.rateLimiter.queueDelete(msg.channel, msg).catch(catcher(279));
|
|
this.client.logger.debug(log + '\nSanctioned');
|
|
|
|
// NOTE: this will have to be changed whenever the moderation manager is finished and properly supports sth like this
|
|
this._moderate(action, guild, channel, member, moderationPoints, silent, msg.format('W_FILTER_ACTION'), filterResult, message);
|
|
|
|
} else {
|
|
this.client.rateLimiter.queueDelete(msg.channel, msg).catch(catcher(286));
|
|
this.client.logger.debug(log);
|
|
}
|
|
|
|
}
|
|
|
|
async flagMessages(message, edited) {
|
|
|
|
const { guild, author, channel } = message;
|
|
if (!guild || author.bot) return;
|
|
|
|
const member = message.member || await guild.members.fetch(author.id).catch();
|
|
const settings = await guild.settings();
|
|
const { wordWatcher: setting } = settings;
|
|
const { words, bypass, ignore, channel: _logChannel } = setting;
|
|
const roles = member?.roles.cache.map((r) => r.id) || [];
|
|
|
|
if (!_logChannel || words.length === 0 || roles.some((r) => bypass.includes(r.id)) || ignore.includes(channel.id)) return;
|
|
|
|
const logChannel = await guild.resolveChannel(_logChannel);
|
|
const msg = edited || message;
|
|
if (!msg.content) return;
|
|
const content = FilterUtil.normalise(msg.cleanContent);
|
|
let match = null;
|
|
|
|
for (const reg of words) {
|
|
|
|
match = content.match(new RegExp(reg, 'iu'));
|
|
|
|
if (match) break;
|
|
|
|
}
|
|
|
|
if (!match) return;
|
|
|
|
const context = channel.messages.cache.sort((m1, m2) => m2.createdTimestamp - m1.createdTimestamp).first(5);
|
|
const embed = {
|
|
title: `⚠️ Word trigger in **#${channel.name}**`,
|
|
description: stripIndents`
|
|
**[Jump to message](${msg.link})**
|
|
`, // ** User:** <@${ author.id }>
|
|
color: 15120384,
|
|
fields: context.reverse().reduce((acc, val) => {
|
|
const text = val.content.length ? val.content.replace(match, '**__$&__**') : '**NO CONTENT**';
|
|
acc.push({
|
|
name: `${val.author.tag} (${val.author.id}) - ${val.id}`,
|
|
value: text.length < 1024 ? text : text.substring(0, 1013) + '...'
|
|
});
|
|
if (text.length > 1024) acc.push({
|
|
name: `\u200b`,
|
|
value: '...' + text.substring(1013, 2034)
|
|
});
|
|
return acc;
|
|
}, [])
|
|
};
|
|
|
|
logChannel.send({ embed });
|
|
|
|
}
|
|
|
|
async filterLinks(message, edited) {
|
|
|
|
const { guild, author, channel } = message;
|
|
if (!guild || author.bot) return;
|
|
|
|
const member = message.member || await guild.members.fetch(author.id).catch();
|
|
const { resolver } = this.client;
|
|
const settings = await guild.settings();
|
|
const { linkFilter: setting, moderationPoints } = settings;
|
|
const { bypass, ignore, actions, silent, enabled, blacklist, whitelist, mode } = setting;
|
|
if (!enabled) return;
|
|
const roles = member?.roles.cache.map((r) => r.id) || [];
|
|
|
|
if (roles.some((r) => bypass.includes(r.id)) || ignore.includes(channel.id)) return;
|
|
|
|
const msg = edited || message;
|
|
if (!msg.content) return;
|
|
const content = msg.content.split('').join(''); //Copy the string...
|
|
const linkRegG = /(https?:\/\/(www\.)?)?(?<domain>([a-z0-9-]{1,63}\.)?([a-z0-9-]{2,63})(\.[a-z0-9-]{2,63})(\.[a-z0-9-]{2,63})?)(\/\S*)?/iug;
|
|
const linkReg = /(https?:\/\/(www\.)?)?(?<domain>([a-z0-9-]{1,63}\.)?([a-z0-9-]{2,63})(\.[a-z0-9-]{2,63})(\.[a-z0-9-]{2,63})?)(\/\S*)?/iu;
|
|
let matches = content.match(linkRegG);
|
|
if (!matches) matches = content.replace(/\s/u, '').match(linkRegG);
|
|
if (!matches) return;
|
|
let remove = false;
|
|
const filterResult = {};
|
|
const _whitelist = mode === 'whitelist';
|
|
|
|
for (const match of matches) {
|
|
const { domain } = match.match(linkReg).groups;
|
|
|
|
// eslint-disable-next-line brace-style
|
|
if (!_whitelist && blacklist.some((dom) => { return dom.includes(domain) || domain.includes(dom); })) {
|
|
filterResult.match = domain;
|
|
filterResult.matcher = 'link blacklist';
|
|
remove = true;
|
|
break;
|
|
} else if (_whitelist) {
|
|
// eslint-disable-next-line brace-style
|
|
if (whitelist.some((dom) => { return dom.includes(domain) || domain.includes(dom); })) continue;
|
|
const valid = await resolver.validateDomain(domain);
|
|
if (!valid) continue;
|
|
|
|
filterResult.match = domain;
|
|
filterResult.matcher = 'link whitelist';
|
|
remove = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if (!remove) return;
|
|
msg.filtered = filterResult;
|
|
if (!silent) {
|
|
const res = await this.client.rateLimiter.limitSend(msg.channel, msg.format('L_FILTER_DELETE', { user: author.id }), undefined, 'linkFilter');
|
|
//const res = await msg.formattedRespond(`L_FILTER_DELETE`, { params: { user: author.id } });
|
|
if (res) res.delete({ timeout: 10000 });
|
|
}
|
|
|
|
if (actions.length) {
|
|
|
|
let action = actions.find((act) => {
|
|
return act.trigger.includes(filterResult.match);
|
|
});
|
|
if (!action) action = actions.find((act) => {
|
|
return act.trigger === mode;
|
|
});
|
|
if (!action) action = actions.find((act) => {
|
|
return act.trigger === 'generic';
|
|
});
|
|
|
|
if (!action) return msg.delete();
|
|
|
|
msg.filtered.sanctioned = true;
|
|
this.client.rateLimiter.queueDelete(msg.channel, msg);
|
|
//msg.delete();
|
|
|
|
this._moderate(action, guild, channel, member, moderationPoints, silent, msg.format('L_FILTER_ACTION'), filterResult, message);
|
|
|
|
} else this.client.rateLimiter.queueDelete(msg.channel, msg); //msg.delete();
|
|
|
|
}
|
|
|
|
async filterInvites(message, edited) {
|
|
|
|
const { guild, author, channel } = message;
|
|
if (!guild || author.bot) return;
|
|
|
|
const member = message.member || await guild.members.fetch(author.id).catch();
|
|
const settings = await guild.settings();
|
|
const { inviteFilter: setting, moderationPoints } = settings;
|
|
const { bypass, ignore, actions, silent, enabled } = setting;
|
|
if (!enabled) return;
|
|
const roles = member?.roles.cache.map((r) => r.id) || [];
|
|
|
|
if (roles.some((r) => bypass.includes(r.id)) || ignore.includes(channel.id)) return;
|
|
|
|
const msg = edited || message;
|
|
const { content } = msg;
|
|
if (!content) return;
|
|
|
|
const reg = /((discord)?\s?\.?\s?gg\s?|discord(app)?\.com\/invite)\/\s?(?<code>[a-z0-9]+)/iu;
|
|
const match = content.match(reg);
|
|
if (!match) return;
|
|
|
|
const result = await guild.checkInvite(match.groups.code);
|
|
if (!result) { // Doesn't resolve to the origin server
|
|
|
|
let action = null;
|
|
if (actions.length) [action] = actions;
|
|
|
|
msg.filtered = {
|
|
match: match[0],
|
|
matcher: 'invites'
|
|
};
|
|
if (!action) return this.client.rateLimiter.queueDelete(msg.channel, msg); //msg.delete();
|
|
if (!silent) {
|
|
const res = await this.client.rateLimiter.limitSend(msg.channel, msg.format('I_FILTER_DELETE', { user: author.id }), undefined, 'inviteFilter');
|
|
if (res) res.delete({ timeout: 10000 });
|
|
}
|
|
msg.filtered.sactioned = true;
|
|
this.client.rateLimiter.queueDelete(msg.channel, msg);
|
|
|
|
this._moderate(action, guild, channel, member, moderationPoints, silent, msg.format('I_FILTER_ACTION'), { filtered: msg.filtered }, message);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
async filterMentions(message) {
|
|
|
|
const { guild, author, channel } = message;
|
|
if (!guild || author.bot) return;
|
|
|
|
const member = message.member || await guild.members.fetch(author.id).catch();
|
|
const settings = await guild.settings();
|
|
const { mentionFilter: setting, moderationPoints } = settings;
|
|
const { bypass, ignore, enabled, silent, unique, mentions, actions } = setting;
|
|
const roles = member?.roles.cache.map((r) => r.id) || [];
|
|
|
|
if (!enabled || roles.some((r) => bypass.includes(r.id)) || ignore.includes(channel.id)) return;
|
|
|
|
const reg = /<@!?[0-9]{18,22}>/gu;
|
|
const { content } = message;
|
|
if (!content) return;
|
|
//const mentions = content.match(reg);
|
|
|
|
}
|
|
|
|
}; |