@lordbex/thelounge 4.4.3-blowfish

package/dist/server/helper.js

@@ -0,0 +1,161 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_json_1 = __importDefault(require("../package.json"));
+const lodash_1 = __importDefault(require("lodash"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const net_1 = __importDefault(require("net"));
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+const crypto_1 = __importDefault(require("crypto"));
+const Helper = {
+    expandHome,
+    getVersion,
+    getVersionCacheBust,
+    getVersionNumber,
+    getGitCommit,
+    ip2hex,
+    parseHostmask,
+    compareHostmask,
+    compareWithWildcard,
+    catch_to_error,
+    password: {
+        hash: passwordHash,
+        compare: passwordCompare,
+        requiresUpdate: passwordRequiresUpdate,
+    },
+};
+exports.default = Helper;
+function getVersion() {
+    const gitCommit = getGitCommit();
+    const version = `v${package_json_1.default.version}`;
+    return gitCommit ? `source (${gitCommit} / ${version})` : version;
+}
+function getVersionNumber() {
+    return package_json_1.default.version;
+}
+let _fetchedGitCommit = false;
+let _gitCommit = null;
+function getGitCommit() {
+    if (_fetchedGitCommit) {
+        return _gitCommit;
+    }
+    _fetchedGitCommit = true;
+    // --git-dir ".git" makes git only check current directory for `.git`, and not travel upwards
+    // We set cwd to the location of `index.js` as soon as the process is started
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        _gitCommit = require("child_process")
+            .execSync('git --git-dir ".git" rev-parse --short HEAD', // Returns hash of current commit
+        { stdio: ["ignore", "pipe", "ignore"] })
+            .toString()
+            .trim();
+        return _gitCommit;
+    }
+    catch (e) {
+        // Not a git repository or git is not installed
+        _gitCommit = null;
+        return null;
+    }
+}
+function getVersionCacheBust() {
+    const hash = crypto_1.default.createHash("sha256").update(Helper.getVersion()).digest("hex");
+    return hash.substring(0, 10);
+}
+function ip2hex(address) {
+    // no ipv6 support
+    if (!net_1.default.isIPv4(address)) {
+        return "00000000";
+    }
+    return address
+        .split(".")
+        .map(function (octet) {
+        let hex = parseInt(octet, 10).toString(16);
+        if (hex.length === 1) {
+            hex = "0" + hex;
+        }
+        return hex;
+    })
+        .join("");
+}
+// Expand ~ into the current user home dir.
+// This does *not* support `~other_user/tmp` => `/home/other_user/tmp`.
+function expandHome(shortenedPath) {
+    if (!shortenedPath) {
+        return "";
+    }
+    const home = os_1.default.homedir().replace("$", "$$$$");
+    return path_1.default.resolve(shortenedPath.replace(/^~($|\/|\\)/, home + "$1"));
+}
+function passwordRequiresUpdate(password) {
+    return bcryptjs_1.default.getRounds(password) !== 11;
+}
+function passwordHash(password) {
+    return bcryptjs_1.default.hashSync(password, bcryptjs_1.default.genSaltSync(11));
+}
+function passwordCompare(password, expected) {
+    return bcryptjs_1.default.compare(password, expected);
+}
+function parseHostmask(hostmask) {
+    let nick = "";
+    let ident = "*";
+    let hostname = "*";
+    let parts = [];
+    // Parse hostname first, then parse the rest
+    parts = hostmask.split("@");
+    if (parts.length >= 2) {
+        hostname = parts[1] || "*";
+        hostmask = parts[0];
+    }
+    hostname = hostname.toLowerCase();
+    parts = hostmask.split("!");
+    if (parts.length >= 2) {
+        ident = parts[1] || "*";
+        hostmask = parts[0];
+    }
+    ident = ident.toLowerCase();
+    nick = hostmask.toLowerCase() || "*";
+    const result = {
+        nick: nick,
+        ident: ident,
+        hostname: hostname,
+    };
+    return result;
+}
+function compareHostmask(a, b) {
+    return (compareWithWildcard(a.nick, b.nick) &&
+        compareWithWildcard(a.ident, b.ident) &&
+        compareWithWildcard(a.hostname, b.hostname));
+}
+function compareWithWildcard(a, b) {
+    // we allow '*' and '?' wildcards in our comparison.
+    // this is mostly aligned with https://modern.ircdocs.horse/#wildcard-expressions
+    // but we do not support the escaping. The ABNF does not seem to be clear as to
+    // how to escape the escape char '\', which is valid in a nick,
+    // whereas the wildcards tend not to be (as per RFC1459).
+    // The "*" wildcard is ".*" in regex, "?" is "."
+    // so we tokenize and join with the proper char back together,
+    // escaping any other regex modifier
+    const wildmany_split = a.split("*").map((sub) => {
+        const wildone_split = sub.split("?").map((p) => lodash_1.default.escapeRegExp(p));
+        return wildone_split.join(".");
+    });
+    const user_regex = wildmany_split.join(".*");
+    const re = new RegExp(`^${user_regex}$`, "i"); // case insensitive
+    return re.test(b);
+}
+function catch_to_error(prefix, err) {
+    let msg;
+    if (err instanceof Error) {
+        msg = err.message;
+    }
+    else if (typeof err === "string") {
+        msg = err;
+    }
+    else {
+        msg = err.toString();
+    }
+    return new Error(`${prefix}: ${msg}`);
+}

package/dist/server/identification.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const net_1 = __importDefault(require("net"));
+const chalk_1 = __importDefault(require("chalk"));
+const helper_1 = __importDefault(require("./helper"));
+const config_1 = __importDefault(require("./config"));
+const log_1 = __importDefault(require("./log"));
+class Identification {
+    connectionId;
+    connections;
+    oidentdFile;
+    constructor(startedCallback) {
+        this.connectionId = 0;
+        this.connections = new Map();
+        if (typeof config_1.default.values.oidentd === "string") {
+            this.oidentdFile = helper_1.default.expandHome(config_1.default.values.oidentd);
+            log_1.default.info(`Oidentd file: ${chalk_1.default.green(this.oidentdFile)}`);
+            this.refresh();
+        }
+        if (config_1.default.values.identd.enable) {
+            if (this.oidentdFile) {
+                log_1.default.warn("Using both identd and oidentd at the same time, this is most likely not intended.");
+            }
+            const server = net_1.default.createServer(this.serverConnection.bind(this));
+            server.on("error", (err) => {
+                startedCallback(this, err);
+            });
+            server.listen({
+                port: config_1.default.values.identd.port || 113,
+                host: config_1.default.values.bind,
+            }, () => {
+                const address = server.address();
+                if (typeof address === "string") {
+                    log_1.default.info(`Identd server available on ${chalk_1.default.green(address)}`);
+                }
+                else if (address?.address) {
+                    log_1.default.info(`Identd server available on ${chalk_1.default.green(address.address + ":" + address.port.toString())}`);
+                }
+                startedCallback(this);
+            });
+        }
+        else {
+            startedCallback(this);
+        }
+    }
+    serverConnection(socket) {
+        socket.on("error", (err) => log_1.default.error(`Identd socket error: ${err}`));
+        socket.setTimeout(5000, () => {
+            log_1.default.warn(`identd: no data received, closing connection to ${socket.remoteAddress || "undefined"}`);
+            socket.destroy();
+        });
+        socket.once("data", (data) => {
+            this.respondToIdent(socket, data);
+            socket.end();
+        });
+    }
+    respondToIdent(socket, buffer) {
+        if (!socket.remoteAddress) {
+            log_1.default.warn("identd: no remote address");
+            return;
+        }
+        const data = buffer.toString().split(",");
+        const lport = parseInt(data[0], 10) || 0;
+        const fport = parseInt(data[1], 10) || 0;
+        if (lport < 1 || fport < 1 || lport > 65535 || fport > 65535) {
+            log_1.default.warn(`identd: bogus request from ${socket.remoteAddress}`);
+            return;
+        }
+        log_1.default.debug(`identd: remote ${socket.remoteAddress} query ${lport}, ${fport}`);
+        for (const connection of this.connections.values()) {
+            // we only want to respond if all the ip,port tuples match, to avoid user enumeration
+            if (connection.socket.remotePort === fport &&
+                connection.socket.localPort === lport &&
+                socket.remoteAddress === connection.socket.remoteAddress &&
+                socket.localAddress === connection.socket.localAddress) {
+                const reply = `${lport}, ${fport} : USERID : TheLounge : ${connection.user}\r\n`;
+                log_1.default.debug(`identd: reply is ${reply.trimEnd()}`);
+                socket.write(reply);
+                return;
+            }
+        }
+        const reply = `${lport}, ${fport} : ERROR : NO-USER\r\n`;
+        log_1.default.debug(`identd: reply is ${reply.trimEnd()}`);
+        socket.write(reply);
+    }
+    addSocket(socket, user) {
+        const id = ++this.connectionId;
+        this.connections.set(id, { socket, user });
+        if (this.oidentdFile) {
+            this.refresh();
+        }
+        return id;
+    }
+    removeSocket(id) {
+        this.connections.delete(id);
+        if (this.oidentdFile) {
+            this.refresh();
+        }
+    }
+    refresh() {
+        let file = "# Warning: file generated by The Lounge: changes will be overwritten!\n";
+        this.connections.forEach((connection, id) => {
+            if (!connection.socket.remotePort || !connection.socket.localPort) {
+                // Race condition: this can happen when more than one socket gets disconnected at
+                // once, since we `refresh()` for each one being added/removed. This results
+                // in there possibly being one or more disconnected sockets remaining when we get here.
+                log_1.default.warn(`oidentd: socket has no remote or local port (id=${id}). See https://github.com/thelounge/thelounge/pull/4695.`);
+                return;
+            }
+            if (!connection.socket.remoteAddress) {
+                log_1.default.warn(`oidentd: socket has no remote address, will not respond to queries`);
+                return;
+            }
+            if (!connection.socket.localAddress) {
+                log_1.default.warn(`oidentd: socket has no local address, will not respond to queries`);
+                return;
+            }
+            // we only want to respond if all the ip,port tuples match, to avoid user enumeration
+            file +=
+                `to ${connection.socket.remoteAddress}` +
+                    ` fport ${connection.socket.remotePort}` +
+                    ` from ${connection.socket.localAddress}` +
+                    ` lport ${connection.socket.localPort}` +
+                    ` { reply "${connection.user}" }\n`;
+        });
+        if (this.oidentdFile) {
+            fs_1.default.writeFile(this.oidentdFile, file, { flag: "w+" }, function (err) {
+                if (err) {
+                    log_1.default.error("Failed to update oidentd file!", err.message);
+                }
+            });
+        }
+    }
+}
+exports.default = Identification;

package/dist/server/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./command-line");

package/dist/server/log.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const read_1 = __importDefault(require("read"));
+function timestamp() {
+    const datetime = new Date().toISOString().split(".")[0].replace("T", " ");
+    return chalk_1.default.dim(datetime);
+}
+const log = {
+    /* eslint-disable no-console */
+    error(...args) {
+        console.error(timestamp(), chalk_1.default.red("[ERROR]"), ...args);
+    },
+    warn(...args) {
+        console.error(timestamp(), chalk_1.default.yellow("[WARN]"), ...args);
+    },
+    info(...args) {
+        console.log(timestamp(), chalk_1.default.blue("[INFO]"), ...args);
+    },
+    debug(...args) {
+        console.log(timestamp(), chalk_1.default.green("[DEBUG]"), ...args);
+    },
+    raw(...args) {
+        console.log(...args);
+    },
+    /* eslint-enable no-console */
+    prompt(options, callback) {
+        options.prompt = [timestamp(), chalk_1.default.cyan("[PROMPT]"), options.text].join(" ");
+        (0, read_1.default)(options, callback);
+    },
+};
+exports.default = log;

package/dist/server/models/chan.js

@@ -0,0 +1,275 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = __importDefault(require("lodash"));
+const log_1 = __importDefault(require("../log"));
+const config_1 = __importDefault(require("../config"));
+const user_1 = __importDefault(require("./user"));
+const storage_1 = __importDefault(require("../plugins/storage"));
+const prefix_1 = __importDefault(require("./prefix"));
+const msg_1 = require("../../shared/types/msg");
+const chan_1 = require("../../shared/types/chan");
+class Chan {
+    // TODO: don't force existence, figure out how to make TS infer it.
+    id;
+    messages;
+    name;
+    key;
+    topic;
+    firstUnread;
+    unread;
+    highlight;
+    users;
+    muted;
+    type;
+    state;
+    // mIRC FiSH Blowfish key, stored server-side only
+    blowfishKey;
+    userAway;
+    special;
+    data;
+    closed;
+    num_users;
+    constructor(attr) {
+        lodash_1.default.defaults(this, attr, {
+            id: 0,
+            messages: [],
+            name: "",
+            key: "",
+            topic: "",
+            type: chan_1.ChanType.CHANNEL,
+            state: chan_1.ChanState.PARTED,
+            firstUnread: 0,
+            unread: 0,
+            highlight: 0,
+            users: new Map(),
+            muted: false,
+        });
+    }
+    destroy() {
+        this.dereferencePreviews(this.messages);
+    }
+    pushMessage(client, msg, increasesUnread = false) {
+        const chanId = this.id;
+        msg.id = client.idMsg++;
+        // If this channel is open in any of the clients, do not increase unread counter
+        const isOpen = lodash_1.default.find(client.attachedClients, { openChannel: chanId }) !== undefined;
+        if (msg.self) {
+            // reset counters/markers when receiving self-/echo-message
+            this.unread = 0;
+            this.firstUnread = msg.id;
+            this.highlight = 0;
+        }
+        else if (!isOpen) {
+            if (!this.firstUnread) {
+                this.firstUnread = msg.id;
+            }
+            if (increasesUnread || msg.highlight) {
+                this.unread++;
+            }
+            if (msg.highlight) {
+                this.highlight++;
+            }
+        }
+        client.emit("msg", { chan: chanId, msg, unread: this.unread, highlight: this.highlight });
+        // Never store messages in public mode as the session
+        // is completely destroyed when the page gets closed
+        if (config_1.default.values.public) {
+            return;
+        }
+        // showInActive is only processed on "msg", don't need it on page reload
+        if (msg.showInActive) {
+            delete msg.showInActive;
+        }
+        this.writeUserLog(client, msg);
+        if (config_1.default.values.maxHistory >= 0 && this.messages.length > config_1.default.values.maxHistory) {
+            const deleted = this.messages.splice(0, this.messages.length - config_1.default.values.maxHistory);
+            // If maxHistory is 0, image would be dereferenced before client had a chance to retrieve it,
+            // so for now, just don't implement dereferencing for this edge case.
+            if (config_1.default.values.maxHistory > 0) {
+                this.dereferencePreviews(deleted);
+            }
+        }
+    }
+    dereferencePreviews(messages) {
+        if (!config_1.default.values.prefetch || !config_1.default.values.prefetchStorage) {
+            return;
+        }
+        messages.forEach((message) => {
+            if (message.previews) {
+                message.previews.forEach((preview) => {
+                    if (preview.thumb) {
+                        storage_1.default.dereference(preview.thumb);
+                        preview.thumb = "";
+                    }
+                });
+            }
+        });
+    }
+    getSortedUsers(irc) {
+        const users = Array.from(this.users.values());
+        if (!irc || !irc.network || !irc.network.options || !irc.network.options.PREFIX) {
+            return users;
+        }
+        const userModeSortPriority = {};
+        irc.network.options.PREFIX.forEach((prefix, index) => {
+            userModeSortPriority[prefix.symbol] = index;
+        });
+        userModeSortPriority[""] = 99; // No mode is lowest
+        return users.sort(function (a, b) {
+            if (a.mode === b.mode) {
+                return a.nick.toLowerCase() < b.nick.toLowerCase() ? -1 : 1;
+            }
+            return userModeSortPriority[a.mode] - userModeSortPriority[b.mode];
+        });
+    }
+    findMessage(msgId) {
+        return this.messages.find((message) => message.id === msgId);
+    }
+    findUser(nick) {
+        return this.users.get(nick.toLowerCase());
+    }
+    getUser(nick) {
+        return this.findUser(nick) || new user_1.default({ nick }, new prefix_1.default([]));
+    }
+    setUser(user) {
+        this.users.set(user.nick.toLowerCase(), user);
+    }
+    removeUser(user) {
+        this.users.delete(user.nick.toLowerCase());
+    }
+    /**
+     * Get a clean clone of this channel that will be sent to the client.
+     * This function performs manual cloning of channel object for
+     * better control of performance and memory usage.
+     *
+     * @param {(int|bool)} lastActiveChannel - Last known active user channel id (needed to control how many messages are sent)
+     *                                         If true, channel is assumed active.
+     * @param {int} lastMessage - Last message id seen by active client to avoid sending duplicates.
+     */
+    getFilteredClone(lastActiveChannel, lastMessage) {
+        let msgs;
+        // If client is reconnecting, only send new messages that client has not seen yet
+        if (lastMessage && lastMessage > -1) {
+            // When reconnecting, always send up to 100 messages to prevent message gaps on the client
+            // See https://github.com/thelounge/thelounge/issues/1883
+            msgs = this.messages.filter((m) => m.id > lastMessage).slice(-100);
+        }
+        else {
+            // If channel is active, send up to 100 last messages, for all others send just 1
+            // Client will automatically load more messages whenever needed based on last seen messages
+            const messagesToSend = lastActiveChannel === true || this.id === lastActiveChannel ? 100 : 1;
+            msgs = this.messages.slice(-messagesToSend);
+        }
+        return {
+            id: this.id,
+            messages: msgs,
+            totalMessages: this.messages.length,
+            name: this.name,
+            key: this.key,
+            topic: this.topic,
+            firstUnread: this.firstUnread,
+            unread: this.unread,
+            highlight: this.highlight,
+            muted: this.muted,
+            type: this.type,
+            state: this.state,
+            special: this.special,
+            data: this.data,
+            closed: this.closed,
+            num_users: this.num_users,
+        };
+        // TODO: funny array mutation below might need to be reproduced
+        // static optionalProperties = ["userAway", "special", "data", "closed", "num_users"];
+        // return Object.keys(this).reduce((newChannel, prop) => {
+        // 	if (Chan.optionalProperties.includes(prop)) {
+        // 		if (this[prop] !== undefined || (Array.isArray(this[prop]) && this[prop].length)) {
+        // 			newChannel[prop] = this[prop];
+        // 		}
+        // 	}
+    }
+    writeUserLog(client, msg) {
+        this.messages.push(msg);
+        // Are there any logs enabled
+        if (client.messageStorage.length === 0) {
+            return;
+        }
+        const targetChannel = this;
+        // Is this particular message or channel loggable
+        if (!msg.isLoggable() || !this.isLoggable()) {
+            // Because notices are nasty and can be shown in active channel on the client
+            // if there is no open query, we want to always log notices in the sender's name
+            if (msg.type === msg_1.MessageType.NOTICE && msg.showInActive) {
+                targetChannel.name = msg.from.nick || ""; // TODO: check if || works
+            }
+            else {
+                return;
+            }
+        }
+        // Find the parent network where this channel is in
+        const target = client.find(this.id);
+        if (!target) {
+            return;
+        }
+        for (const messageStorage of client.messageStorage) {
+            messageStorage.index(target.network, targetChannel, msg).catch((e) => log_1.default.error(e));
+        }
+    }
+    loadMessages(client, network) {
+        if (!this.isLoggable()) {
+            return;
+        }
+        if (!network.irc) {
+            // Network created, but misconfigured
+            log_1.default.warn(`Failed to load messages for ${client.name}, network ${network.name} is not initialized.`);
+            return;
+        }
+        if (!client.messageProvider) {
+            if (network.irc.network.cap.isEnabled("znc.in/playback")) {
+                // if we do have a message provider we might be able to only fetch partial history,
+                // so delay the cap in this case.
+                requestZncPlayback(this, network, 0);
+            }
+            return;
+        }
+        client.messageProvider
+            .getMessages(network, this, () => client.idMsg++)
+            .then((messages) => {
+            if (messages.length === 0) {
+                if (network.irc.network.cap.isEnabled("znc.in/playback")) {
+                    requestZncPlayback(this, network, 0);
+                }
+                return;
+            }
+            this.messages.unshift(...messages);
+            if (!this.firstUnread) {
+                this.firstUnread = messages[messages.length - 1].id;
+            }
+            client.emit("more", {
+                chan: this.id,
+                messages: messages.slice(-100),
+                totalMessages: messages.length,
+            });
+            if (network.irc.network.cap.isEnabled("znc.in/playback")) {
+                const from = Math.floor(messages[messages.length - 1].time.getTime() / 1000);
+                requestZncPlayback(this, network, from);
+            }
+        })
+            .catch((err) => log_1.default.error(`Failed to load messages for ${client.name}: ${err.toString()}`));
+    }
+    isLoggable() {
+        return this.type === chan_1.ChanType.CHANNEL || this.type === chan_1.ChanType.QUERY;
+    }
+    setMuteStatus(muted) {
+        this.muted = !!muted;
+    }
+}
+function requestZncPlayback(channel, network, from) {
+    if (!network.irc) {
+        throw new Error(`requestZncPlayback: no irc field on network "${network.name}", this is a bug`);
+    }
+    network.irc.raw("ZNC", "*playback", "PLAY", channel.name, from.toString());
+}
+exports.default = Chan;