src/services/LogServer.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 bcrypt from "bcrypt";
import chalk from "chalk";
import { Server, Socket } from "socket.io";
import Client from "../core/Client";
import Service from "../core/Service";
import { logInfo, logWarn } from "../utils/Logger";

export const name = "logServer";

export default class LogServer extends Service {
    public readonly MAX_CONNECTIONS = 5;
    protected connections = 0;
    private _io?: Server;
    public readonly sockets: Array<Socket> = [];

    constructor(client: Client) {
        super(client);

        if (!client.configManager.systemConfig.log_server?.auto_start) {
            return;
        }

        this.initialize();
    }

    get io() {
        return this._io;
    }

    initialize() {
        this._io = new Server();
        this.setupListeners();
    }

    start() {
        this.initialize();
        this.listen();
    }

    close() {
        this.io?.close();
        this._io = undefined;
    }

    isAuthorized(socket: Socket) {
        const { authorization } = socket.request.headers;
        const [type, password] = authorization?.split(/\s+/) ?? ["", ""];

        if (type !== "Bearer") {
            socket.send("[error] Only bearer tokens are supported!");
            socket.disconnect(true);
            return false;
        }

        if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
            socket.send("[error] Authentication failed");
            socket.disconnect(true);
            return false;
        }

        return true;
    }

    setupListeners() {
        this.io?.on("connection", socket => {
            if (this.connections >= this.MAX_CONNECTIONS) {
                socket.disconnect();
                return;
            }

            this.connections++;
            logInfo("New client connected to the log server", socket.id);

            socket.on("disconnect", reason => {
                this.connections--;
                logInfo("Client Disconnected from log server: ", socket.id, reason);
                const index = this.sockets.findIndex(s => s.id === socket.id);

                if (index !== -1) {
                    this.sockets.splice(index, 1);
                }
            });

            if (!this.isAuthorized(socket)) {
                logWarn("Unauthorized client attempted to connect to the log server", socket.id);
                return;
            }

            socket.write(`${chalk.cyan("[info]")} Connection Accepted`);

            this.sockets.push(socket);
        });
    }

    send(message: string) {
        for (const socket of this.sockets) {
            socket.send(message);
        }
    }

    log(message: string) {
        this.sockets.forEach(socket => {
            socket.send(`${message}`);
        });
    }

    listen() {
        let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
        port = isNaN(port) ? 3500 : port;

        this.io?.listen(port);
        logInfo("The log server is running at port", port);
    }
}
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 bcrypt from "bcrypt";
21			import chalk from "chalk";
22			import { Server, Socket } from "socket.io";
23			import Client from "../core/Client";
24			import Service from "../core/Service";
25			import { logInfo, logWarn } from "../utils/Logger";
26
27			export const name = "logServer";
28
29			export default class LogServer extends Service {
30			public readonly MAX_CONNECTIONS = 5;
31			protected connections = 0;
32			private _io?: Server;
33			public readonly sockets: Array<Socket> = [];
34
35			constructor(client: Client) {
36			super(client);
37
38			if (!client.configManager.systemConfig.log_server?.auto_start) {
39			return;
40			}
41
42			this.initialize();
43			}
44
45			get io() {
46			return this._io;
47			}
48
49			initialize() {
50			this._io = new Server();
51			this.setupListeners();
52			}
53
54			start() {
55			this.initialize();
56			this.listen();
57			}
58
59			close() {
60			this.io?.close();
61			this._io = undefined;
62			}
63
64			isAuthorized(socket: Socket) {
65			const { authorization } = socket.request.headers;
66			const [type, password] = authorization?.split(/\s+/) ?? ["", ""];
67
68			if (type !== "Bearer") {
69			socket.send("[error] Only bearer tokens are supported!");
70			socket.disconnect(true);
71			return false;
72			}
73
74			if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
75			socket.send("[error] Authentication failed");
76			socket.disconnect(true);
77			return false;
78			}
79
80			return true;
81			}
82
83			setupListeners() {
84			this.io?.on("connection", socket => {
85			if (this.connections >= this.MAX_CONNECTIONS) {
86			socket.disconnect();
87			return;
88			}
89
90			this.connections++;
91			logInfo("New client connected to the log server", socket.id);
92
93			socket.on("disconnect", reason => {
94			this.connections--;
95			logInfo("Client Disconnected from log server: ", socket.id, reason);
96			const index = this.sockets.findIndex(s => s.id === socket.id);
97
98			if (index !== -1) {
99			this.sockets.splice(index, 1);
100			}
101			});
102
103			if (!this.isAuthorized(socket)) {
104			logWarn("Unauthorized client attempted to connect to the log server", socket.id);
105			return;
106			}
107
108			socket.write(`${chalk.cyan("[info]")} Connection Accepted`);
109
110			this.sockets.push(socket);
111			});
112			}
113
114			send(message: string) {
115			for (const socket of this.sockets) {
116			socket.send(message);
117			}
118			}
119
120			log(message: string) {
121			this.sockets.forEach(socket => {
122			socket.send(`${message}`);
123			});
124			}
125
126			listen() {
127			let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
128			port = isNaN(port) ? 3500 : port;
129
130			this.io?.listen(port);
131			logInfo("The log server is running at port", port);
132			}
133			}