peertube-plugin-livechat/server/lib/configuration/channel/sanitize.ts

230 lines
6.4 KiB
TypeScript
Raw Normal View History

2023-08-09 14:16:02 +00:00
import type { RegisterServerOptions } from '@peertube/peertube-types'
2023-09-18 10:23:35 +00:00
import type { ChannelConfigurationOptions } from '../../../../shared/lib/types'
2023-08-09 14:16:02 +00:00
/**
* Sanitize data so that they can safely be used/stored for channel configuration configuration.
2023-08-09 14:16:02 +00:00
* Throw an error if the format is obviously wrong.
* Cleans data (removing empty values, ...)
* @param options Peertube server options
* @param _channelInfos Channel infos
* @param data Input data
*/
async function sanitizeChannelConfigurationOptions (
2023-08-09 14:16:02 +00:00
_options: RegisterServerOptions,
2023-09-18 10:23:35 +00:00
_channelId: number | string,
2023-08-09 14:16:02 +00:00
data: any
): Promise<ChannelConfigurationOptions> {
2023-08-09 14:16:02 +00:00
if (typeof data !== 'object') {
throw new Error('Invalid data type')
}
2023-09-19 16:56:39 +00:00
2023-09-21 17:32:47 +00:00
const botData = data.bot
if (typeof botData !== 'object') {
throw new Error('Invalid data.bot data type')
}
// slowMode not present in livechat <= 8.2.0:
const slowModeData = data.slowMode ?? {}
slowModeData.defaultDuration ??= 0
if (typeof slowModeData !== 'object') {
throw new Error('Invalid data.slowMode data type')
}
2023-09-19 16:56:39 +00:00
const result: ChannelConfigurationOptions = {
2023-09-21 17:32:47 +00:00
bot: {
enabled: _readBoolean(botData, 'enabled'),
nickname: _readSimpleInput(botData, 'nickname', true),
forbiddenWords: await _readForbiddenWords(botData),
quotes: _readQuotes(botData),
commands: _readCommands(botData)
// TODO: bannedJIDs
},
slowMode: {
defaultDuration: _readInteger(slowModeData, 'defaultDuration', 0, 1000)
2023-09-21 17:32:47 +00:00
}
2023-09-19 16:56:39 +00:00
}
return result
}
function _readBoolean (data: any, f: string): boolean {
if (!(f in data)) {
return false
}
if (typeof data[f] !== 'boolean') {
throw new Error('Invalid data type for field ' + f)
}
return data[f]
}
2023-09-21 17:32:47 +00:00
function _readInteger (data: any, f: string, min: number, max: number): number {
if (!(f in data)) {
throw new Error('Missing integer value for field ' + f)
}
const v = parseInt(data[f])
if (isNaN(v)) {
throw new Error('Invalid value type for field ' + f)
}
if (v < min) {
throw new Error('Invalid value type (<min) for field ' + f)
}
if (v > max) {
throw new Error('Invalid value type (>max) for field ' + f)
}
return v
}
function _readSimpleInput (data: any, f: string, strict?: boolean, noSpace?: boolean): string {
2023-09-19 16:56:39 +00:00
if (!(f in data)) {
return ''
}
if (typeof data[f] !== 'string') {
throw new Error('Invalid data type for field ' + f)
}
2023-09-21 17:32:47 +00:00
// Removing control characters.
// eslint-disable-next-line no-control-regex
let s = (data[f] as string).replace(/[\u0000-\u001F\u007F-\u009F]/g, '')
if (strict) {
// Replacing all invalid characters, no need to throw an error..
s = s.replace(/[^\p{L}\p{N}\p{Z}_-]$/gu, '')
}
if (noSpace) {
s = s.replace(/\s+/g, '')
}
2023-09-21 17:32:47 +00:00
return s
}
function _readStringArray (data: any, f: string): string[] {
if (!(f in data)) {
return []
}
if (!Array.isArray(data[f])) {
throw new Error('Invalid data type for field ' + f)
}
const result: string[] = []
for (const v of data[f]) {
if (typeof v !== 'string') {
throw new Error('Invalid data type in a value of field ' + f)
}
if (v === '' || /^\s+$/.test(v)) {
// ignore empty values
continue
}
result.push(v)
}
return result
2023-09-19 16:56:39 +00:00
}
2023-09-25 11:16:15 +00:00
function _readMultiLineString (data: any, f: string): string {
if (!(f in data)) {
return ''
}
if (typeof data[f] !== 'string') {
throw new Error('Invalid data type for field ' + f)
}
2023-09-25 13:37:58 +00:00
// Removing control characters (must authorize \u001A: line feed)
2023-09-25 11:16:15 +00:00
// eslint-disable-next-line no-control-regex
2023-09-25 13:37:58 +00:00
const s = (data[f] as string).replace(/[\u0000-\u0009\u001B-\u001F\u007F-\u009F]/g, '')
2023-09-25 11:16:15 +00:00
return s
}
2023-09-19 16:56:39 +00:00
async function _readRegExpArray (data: any, f: string): Promise<string[]> {
// Note: this function can instanciate a lot of RegExp.
// To avoid freezing the server, we make it async, and will validate each regexp in a separate tick.
if (!(f in data)) {
return []
2023-08-09 14:16:02 +00:00
}
2023-09-19 16:56:39 +00:00
if (!Array.isArray(data[f])) {
throw new Error('Invalid data type for field ' + f)
}
const result: string[] = []
for (const v of data[f]) {
if (typeof v !== 'string') {
throw new Error('Invalid data type in a value of field ' + f)
2023-08-09 14:16:02 +00:00
}
2023-09-19 16:56:39 +00:00
if (v === '' || /^\s+$/.test(v)) {
// ignore empty values
continue
}
// value must be a valid regexp
try {
async function _validate (): Promise<void> {
2023-08-09 14:16:02 +00:00
// eslint-disable-next-line no-new
new RegExp(v)
}
2023-09-19 16:56:39 +00:00
await _validate()
} catch (_err) {
throw new Error('Invalid value in field ' + f)
2023-08-09 14:16:02 +00:00
}
2023-09-19 16:56:39 +00:00
result.push(v)
2023-08-09 14:16:02 +00:00
}
return result
}
2023-09-21 17:32:47 +00:00
async function _readForbiddenWords (botData: any): Promise<ChannelConfigurationOptions['bot']['forbiddenWords']> {
if (!Array.isArray(botData.forbiddenWords)) {
throw new Error('Invalid forbiddenWords data')
}
const result: ChannelConfigurationOptions['bot']['forbiddenWords'] = []
for (const fw of botData.forbiddenWords) {
const regexp = !!fw.regexp
let entries
if (regexp) {
entries = await _readRegExpArray(fw, 'entries')
} else {
entries = _readStringArray(fw, 'entries')
}
const applyToModerators = _readBoolean(fw, 'applyToModerators')
const reason = fw.reason ? _readSimpleInput(fw, 'reason') : undefined
2023-09-25 11:16:15 +00:00
const comments = fw.comments ? _readMultiLineString(fw, 'comments') : undefined
2023-09-21 17:32:47 +00:00
result.push({
regexp,
entries,
applyToModerators,
2023-09-25 11:16:15 +00:00
reason,
comments
2023-09-21 17:32:47 +00:00
})
}
return result
}
function _readQuotes (botData: any): ChannelConfigurationOptions['bot']['quotes'] {
if (!Array.isArray(botData.quotes)) {
throw new Error('Invalid quotes data')
}
const result: ChannelConfigurationOptions['bot']['quotes'] = []
2023-09-22 14:30:12 +00:00
for (const qs of botData.quotes) {
const messages = _readStringArray(qs, 'messages')
const delay = _readInteger(qs, 'delay', 1, 6000)
2023-09-21 17:32:47 +00:00
result.push({
messages,
delay
})
}
return result
}
function _readCommands (botData: any): ChannelConfigurationOptions['bot']['commands'] {
if (!Array.isArray(botData.commands)) {
throw new Error('Invalid commands data')
}
const result: ChannelConfigurationOptions['bot']['commands'] = []
2023-09-22 14:30:12 +00:00
for (const cs of botData.commands) {
const message = _readSimpleInput(cs, 'message')
const command = _readSimpleInput(cs, 'command', false, true)
2023-09-21 17:32:47 +00:00
result.push({
message,
command
})
}
return result
}
2023-08-09 14:16:02 +00:00
export {
sanitizeChannelConfigurationOptions
2023-08-09 14:16:02 +00:00
}