@manch1kz/yanac 1.0.1

package/README.md

@@ -0,0 +1,33 @@
+## Installation
+```npm install -g @manch1kz/yanac```
+
+## Using
+```npm i``` before using if you using this from the source code
+
+Starting the server:
+```
+yanac start server [options]
+```
+
+Starting the сlient:
+```
+yanac start client [options]
+```
+
+Options for server:
+* ```--port <limit>``` - port (default: 3000)
+* ```--limit <limit>``` - chat maximum size (default: 100)
+
+Options for client:
+* ```--port <limit>``` - port (default: 3000)
+* ```--host <limit>``` - host (default: default)
+* ```--name <limit>``` - port (default: random_string)
+
+## Communication demo
+https://github.com/user-attachments/assets/37b0010c-6ea2-436c-96b0-f66d71bb3a7a
+
+
+
+
+
+

package/app.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { Command } from "commander"
+import { Server } from "./server/serverInstance"
+import { Client } from "./client/clientInstance"
+
+const program = new Command()
+    
+program.command("start <type>")
+    .option("--port <port>", "Server port (default: 3000)")
+    .option("--host <host>", "Server host (default: localhost)")
+    .option("--name <name>", "Client name (default: random_str)")
+    .option("--limit <limit>", "Limit of chat storage (default: 100)")
+    .action((str, options) => {
+        switch (str) {
+            case "server":
+                const server = new Server(
+                    Number(options.limit) ? Number(options.limit) : undefined,
+                    Number(options.port) ? Number(options.port) : undefined
+                )
+                break;
+            case "client":
+                const client = new Client(options.name, options.host, Number(options.port) ? Number(options.port) : undefined)
+                break;
+        }
+    })
+
+program.parse()
+    

package/build/app.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const serverInstance_1 = require("./server/serverInstance");
+const clientInstance_1 = require("./client/clientInstance");
+const program = new commander_1.Command();
+program.command("start <type>")
+    .option("--port <port>", "Server port (default: 3000)")
+    .option("--host <host>", "Server host (default: localhost)")
+    .option("--name <name>", "Client name (default: random_str)")
+    .option("--limit <limit>", "Limit of chat storage (default: 100)")
+    .action((str, options) => {
+    switch (str) {
+        case "server":
+            const server = new serverInstance_1.Server(Number(options.limit) ? Number(options.limit) : undefined, Number(options.port) ? Number(options.port) : undefined);
+            break;
+        case "client":
+            const client = new clientInstance_1.Client(options.name, options.host, Number(options.port) ? Number(options.port) : undefined);
+            break;
+    }
+});
+program.parse();

package/build/client/clientInstance.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const net_1 = __importDefault(require("net"));
+const promises_1 = __importDefault(require("readline/promises"));
+const sessionManager_1 = require("../security/sessionManager");
+const processMessage_1 = require("./handlers/processMessage");
+const mainInputHandler_1 = require("./handlers/mainInputHandler");
+const genNameAlias_1 = require("../utils/genNameAlias");
+class Client {
+    manager;
+    rl;
+    name;
+    server;
+    key_generated;
+    constructor(name = (0, genNameAlias_1.genName)(), host = "localhost", port = 3000) {
+        this.name = name;
+        this.server = net_1.default.connect({ host: host, port: port });
+        this.key_generated = false;
+        this.manager = new sessionManager_1.SessionManager();
+        this.rl = promises_1.default.createInterface({ input: process.stdin, output: process.stdout, prompt: `${this.name} >>> ` });
+        this.server.on("connect", () => {
+            this.server.write(JSON.stringify({ type: 'public_key_request', body: this.manager.getClient() }));
+        });
+        this.server.on("data", (data) => {
+            processMessage_1.processMessage.call(this, data);
+        });
+        this.rl.on("line", mainInputHandler_1.onLine.bind(this));
+        this.server.on("close", () => { this.server.end(); process.exit(); });
+        this.rl.on("SIGINT", () => { this.server.end(); process.exit(); });
+    }
+}
+exports.Client = Client;

package/build/client/handlers/mainInputHandler.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onLine = onLine;
+const edUtils_1 = require("../../utils/edUtils");
+function onLine(line) {
+    if (line.length > 0) {
+        process.stdout.moveCursor(0, -1);
+        process.stdout.write('\r\x1B[K');
+        console.log(`${this.name}: ${line}`);
+        if (line == "/exit") {
+            this.rl.emit("SIGINT");
+        }
+        this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', body: [this.name, line] }), this.manager.session_key));
+        this.rl.prompt();
+    }
+    else {
+        process.stdout.moveCursor(0, -1);
+        process.stdout.write('\r\x1B[K');
+        this.rl.prompt();
+    }
+}

package/build/client/handlers/processMessage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMessage = processMessage;
+const edUtils_1 = require("../../utils/edUtils");
+async function processMessage(data) {
+    const cur = this.rl.getCursorPos();
+    let processed;
+    if (this.key_generated) {
+        processed = JSON.parse((0, edUtils_1.decrypt)(data.toString(), this.manager.session_key));
+    }
+    else {
+        processed = JSON.parse(data.toString('utf-8'));
+    }
+    switch (processed.type) {
+        case 'public_key_response':
+            this.manager.setServer(processed.body[1]);
+            this.server.write(JSON.stringify({ type: 'master_key_response', body: [this.manager.getMaster(processed.body[0]), this.name] }));
+            break;
+        case 'finished':
+            this.manager.generateSession();
+            this.key_generated = true;
+            this.server.write((0, edUtils_1.encrypt)(JSON.stringify({ type: "finished", body: this.name }), this.manager.session_key));
+            this.rl.prompt();
+            break;
+        case 'history':
+            process.stdout.write('\r\x1B[K');
+            for (let i = 0; i < processed.body.length; i++) {
+                console.log(processed.body[i][0] + ':', processed.body[i][1]);
+            }
+            console.log('[SERVER]:', this.name, 'connected to server');
+            this.rl.prompt(true);
+            process.stdout.cursorTo(cur.cols);
+            break;
+        case 'msg':
+            process.stdout.write('\r\x1B[K');
+            console.log(processed.data[0] + ':', processed.data[1]);
+            this.rl.prompt(true);
+            process.stdout.cursorTo(cur.cols);
+            break;
+    }
+}

package/build/security/sessionManager.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+class SessionManager {
+    client_random;
+    server_random;
+    master_random;
+    session_key;
+    privateKey;
+    publicKey;
+    constructor() {
+        this.client_random = null;
+        this.server_random = null;
+        this.master_random = null;
+        this.session_key = null;
+        const { publicKey, privateKey } = crypto_1.default.generateKeyPairSync('rsa', {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                format: 'pem',
+                type: 'pkcs1'
+            },
+            privateKeyEncoding: {
+                format: 'pem',
+                type: 'pkcs1'
+            }
+        });
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+    }
+    generateSession() {
+        if (this.client_random && this.server_random && this.master_random) {
+            const sum = this.client_random + this.server_random + Number(this.master_random);
+            this.session_key = crypto_1.default.createHash('sha256').update(String(sum)).digest().toString('hex');
+        }
+    }
+    setClient(client_random) {
+        this.client_random = client_random;
+    }
+    getClient() {
+        if (this.client_random == null) {
+            this.client_random = Math.floor(Math.random() * 5000);
+        }
+        return this.client_random;
+    }
+    getServer() {
+        if (this.server_random == null) {
+            this.server_random = Math.floor(Math.random() * 5000);
+        }
+        return this.server_random;
+    }
+    setServer(server_random) {
+        this.server_random = server_random;
+    }
+    getMaster(public_key) {
+        if (this.master_random == null) {
+            this.master_random = String(Math.floor(Math.random() * 5000));
+        }
+        return crypto_1.default.publicEncrypt({
+            key: public_key,
+            padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+        }, this.master_random).toString('base64');
+    }
+    setMaster(master_random, private_key) {
+        this.master_random = crypto_1.default.privateDecrypt({
+            key: private_key,
+            padding: crypto_1.default.constants.RSA_PKCS1_OAEP_PADDING,
+        }, Buffer.from(master_random, 'base64')).toString();
+    }
+}
+exports.SessionManager = SessionManager;

package/build/server/handlers/processMessage.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processMessage = processMessage;
+const edUtils_1 = require("../../utils/edUtils");
+function processMessage(socket, data) {
+    const socket_item = this.connections.get(socket);
+    const socket_generator = socket_item.generator;
+    let message;
+    if (socket_item.key_generated) {
+        message = JSON.parse((0, edUtils_1.decrypt)(data.toString(), socket_item.generator.session_key));
+    }
+    else {
+        message = JSON.parse(data.toString());
+    }
+    switch (message.type) {
+        case 'msg':
+            this.localChatStore.push(message.body);
+            Array.from(this.connections.keys()).forEach((i) => {
+                if (i != socket) {
+                    i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: message.body }), this.connections.get(i).generator.session_key));
+                }
+            });
+            break;
+        case 'public_key_request':
+            const server_random = this.manager.getServer();
+            socket_generator.setClient(message.body);
+            socket_generator.setServer(server_random);
+            socket.write(JSON.stringify({ type: 'public_key_response', body: [this.manager.publicKey, server_random] }));
+            break;
+        case 'master_key_response':
+            socket_generator.setMaster(message.body[0], this.manager.privateKey);
+            socket_generator.generateSession();
+            socket_item.name = message.body[1];
+            socket_item.key_generated = true;
+            socket.write(JSON.stringify({ type: 'finished' }));
+            break;
+        case 'finished':
+            socket_item.name = message.body;
+            socket.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'history', body: this.localChatStore.getChat() }), socket_generator.session_key));
+            this.localChatStore.push(['[SERVER]', message.body + ' connected to server']);
+            Array.from(this.connections.keys()).forEach((i) => {
+                if (i != socket) {
+                    i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: ['[SERVER]', message.body + ' connected to server'] }), this.connections.get(i).generator.session_key));
+                }
+            });
+            break;
+    }
+}

package/build/server/handlers/setupSocket.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSocket = setupSocket;
+const sessionManager_1 = require("../../security/sessionManager");
+const edUtils_1 = require("../../utils/edUtils");
+function setupSocket(socket, cb) {
+    this.connections.set(socket, { name: null, generator: new sessionManager_1.SessionManager(), key_generated: false });
+    socket.on('close', () => {
+        let body = ['[SERVER]', this.connections.get(socket).name + ' disconnected from server'];
+        this.localChatStore.push(body);
+        Array.from(this.connections.keys()).forEach((i) => {
+            i.write((0, edUtils_1.encrypt)(JSON.stringify({ type: 'msg', data: body }), this.connections.get(i).generator.session_key));
+        });
+        this.connections.delete(socket);
+    });
+    socket.on("error", () => { });
+    socket.on('data', (data) => {
+        cb(socket, data);
+    });
+}

package/build/server/serverInstance.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const net_1 = __importDefault(require("net"));
+const sessionManager_1 = require("../security/sessionManager");
+const localChatStore_1 = require("../utils/localChatStore");
+const processMessage_1 = require("./handlers/processMessage");
+const setupSocket_1 = require("./handlers/setupSocket");
+class Server {
+    localChatStore;
+    server;
+    manager;
+    connections;
+    constructor(limit = 100, port = 3000) {
+        this.localChatStore = new localChatStore_1.LocalChatStore(100);
+        this.manager = new sessionManager_1.SessionManager();
+        this.connections = new Map();
+        this.server = net_1.default.createServer();
+        this.server.on("connection", (socket) => {
+            setupSocket_1.setupSocket.call(this, socket, processMessage_1.processMessage.bind(this));
+        });
+        this.server.listen(port);
+    }
+}
+exports.Server = Server;

package/build/utils/edUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+const crypto_1 = __importDefault(require("crypto"));
+function formatKey(key) {
+    if (key.length > 32) {
+        key = key.slice(0, 32);
+    }
+    else if (key.length < 32) {
+        key += Array.from({ length: 32 - key.length }, () => 0).join('');
+    }
+    return key;
+}
+function encrypt(value, key) {
+    key = formatKey(key);
+    const iv = Buffer.alloc(16, 0);
+    const cipher = crypto_1.default.createCipheriv("aes-256-cbc", key, iv);
+    let encrypted = cipher.update(value, "utf-8", "hex");
+    encrypted += cipher.final("hex");
+    return encrypted;
+}
+function decrypt(value, key) {
+    key = formatKey(key);
+    const iv = Buffer.alloc(16, 0);
+    const decipher = crypto_1.default.createDecipheriv("aes-256-cbc", key, iv);
+    let decrypted = decipher.update(value, "hex", "utf-8");
+    decrypted += decipher.final("utf-8");
+    return decrypted;
+}

package/build/utils/genNameAlias.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genName = genName;
+const crypto_1 = __importDefault(require("crypto"));
+function genName() {
+    return crypto_1.default.randomBytes(8).toString("hex");
+}

package/build/utils/localChatStore.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalChatStore = void 0;
+class LocalChatStore {
+    chat;
+    limit;
+    constructor(limit) {
+        this.chat = [];
+        this.limit = limit;
+    }
+    push(message) {
+        if (this.chat.length >= this.limit) {
+            this.chat.splice(0, 1);
+        }
+        this.chat.push(message);
+    }
+    getChat() {
+        return this.chat;
+    }
+}
+exports.LocalChatStore = LocalChatStore;

package/client/clientInstance.ts

@@ -0,0 +1,34 @@
+import net from 'net'
+import readline from 'readline/promises'
+import { SessionManager } from '../security/sessionManager'
+import { processMessage } from './handlers/processMessage'
+import { onLine } from "./handlers/mainInputHandler"
+import { genName } from '../utils/genNameAlias'
+
+export class Client {
+    manager: SessionManager
+    rl: readline.Interface
+    name: string
+    server: net.Socket
+    key_generated: boolean
+
+    constructor(name=genName(), host="localhost", port=3000) {
+        this.name = name
+        this.server = net.connect({ host: host, port: port })
+        this.key_generated = false
+        this.manager = new SessionManager()
+        this.rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: `${this.name} >>> ` })
+
+        this.server.on("connect", () => {
+            this.server.write(JSON.stringify({type: 'public_key_request', body: this.manager.getClient()}))
+        })
+        this.server.on("data", (data) => {
+            processMessage.call(this, data)
+        })
+
+        this.rl.on("line", onLine.bind(this))
+
+        this.server.on("close", () => {this.server.end(); process.exit()})
+        this.rl.on("SIGINT", () => {this.server.end(); process.exit()})
+    }
+}

package/client/handlers/mainInputHandler.ts

@@ -0,0 +1,21 @@
+import { Client } from "../clientInstance";
+import { encrypt } from "../../utils/edUtils";
+
+function onLine(this: Client, line: string) {
+    if (line.length > 0) {
+        process.stdout.moveCursor(0, -1)
+        process.stdout.write('\r\x1B[K');
+        console.log(`${this.name}: ${line}`)
+        if (line == "/exit") {
+            this.rl.emit("SIGINT")
+        }
+        this.server.write(encrypt(JSON.stringify({type: 'msg', body: [this.name, line]}), this.manager.session_key))
+        this.rl.prompt()
+    } else {
+        process.stdout.moveCursor(0, -1)
+        process.stdout.write('\r\x1B[K');
+        this.rl.prompt()
+    }
+}
+
+export { onLine }

package/client/handlers/processMessage.ts

@@ -0,0 +1,47 @@
+import { decrypt, encrypt } from "../../utils/edUtils"
+import { Client } from "../clientInstance"
+
+async function processMessage(this: Client, data: any) {
+    const cur = this.rl.getCursorPos()
+    let processed
+
+    if (this.key_generated) {
+        processed = JSON.parse(decrypt(data.toString(), this.manager.session_key))
+    } else {
+        processed = JSON.parse(data.toString('utf-8'))
+    }
+   
+    switch (processed.type) {
+        case 'public_key_response':
+            this.manager.setServer(processed.body[1])
+            this.server.write(JSON.stringify({type: 'master_key_response', body: [this.manager.getMaster(processed.body[0]), this.name]}))
+            break;
+        case 'finished':
+            this.manager.generateSession()
+            this.key_generated = true
+            this.server.write(encrypt(JSON.stringify({type: "finished", body: this.name}), this.manager.session_key))
+            this.rl.prompt()
+            break;
+        case 'history':
+            process.stdout.write('\r\x1B[K')
+
+            for (let i = 0; i < processed.body.length; i++) {
+                console.log(processed.body[i][0] + ':', processed.body[i][1])
+            }
+
+            console.log('[SERVER]:', this.name, 'connected to server')
+
+            this.rl.prompt(true)
+            process.stdout.cursorTo(cur.cols)
+            break;
+        case 'msg':
+            process.stdout.write('\r\x1B[K');
+            console.log(processed.data[0] + ':', processed.data[1])
+
+            this.rl.prompt(true)
+            process.stdout.cursorTo(cur.cols)
+            break;
+    }
+}
+
+export { processMessage }

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@manch1kz/yanac",
+  "version": "1.0.1",
+  "description": "(YANAC) Yet another not another chat",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/manch1kz/YANAC"
+  },
+  "main": "./build/app.js",
+  "bin": "./build/app.js",
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "tsc"
+  },
+  "keywords": [
+    "cryptography",
+    "handshake",
+    "tcp",
+    "educational",
+    "cli",
+    "security"
+  ],
+  "author": "manch1kz",
+  "license": "ISC",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "typescript": "^5.0.0"
+  }
+}

package/security/sessionManager.ts

@@ -0,0 +1,78 @@
+import crypto from "crypto"
+
+export class SessionManager {
+    client_random: any
+    server_random: any
+    master_random: any
+    session_key: any
+    privateKey: any
+    publicKey: any
+
+    constructor() {
+        this.client_random = null
+        this.server_random = null
+        this.master_random = null
+        this.session_key = null
+
+        const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+            modulusLength: 2048,
+            publicKeyEncoding: {
+                format: 'pem',
+                type: 'pkcs1'
+            },
+            privateKeyEncoding: {
+                format: 'pem',
+                type: 'pkcs1'
+            }})
+
+        this.privateKey = privateKey
+        this.publicKey = publicKey
+    }
+
+    generateSession() {
+        if (this.client_random && this.server_random && this.master_random) {
+            const sum = this.client_random + this.server_random + Number(this.master_random)
+            this.session_key = crypto.createHash('sha256').update(String(sum)).digest().toString('hex')
+        }
+    }
+
+    setClient(client_random: any) {
+        this.client_random = client_random
+    }
+
+    getClient() {
+        if (this.client_random == null) {
+            this.client_random = Math.floor(Math.random() * 5000)
+        }
+        return this.client_random
+    }
+
+    getServer() {
+        if (this.server_random == null) {
+            this.server_random = Math.floor(Math.random() * 5000)
+        }
+        return this.server_random
+    }
+
+    setServer(server_random: any) {
+        this.server_random = server_random
+    }
+
+    getMaster(public_key: any) {
+        if (this.master_random == null) {
+            this.master_random = String(Math.floor(Math.random() * 5000))
+        }
+
+        return crypto.publicEncrypt({
+            key: public_key,
+            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+        }, this.master_random).toString('base64')  
+    }
+
+    setMaster(master_random: any, private_key: any) {
+        this.master_random = crypto.privateDecrypt({
+            key: private_key,
+            padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
+        }, Buffer.from(master_random, 'base64')).toString()
+    }
+}

package/server/handlers/processMessage.ts

@@ -0,0 +1,57 @@
+import { encrypt, decrypt } from "../../utils/edUtils"
+import { Server } from "../serverInstance"
+
+function processMessage(this: Server, socket: any, data: any) {
+    const socket_item = this.connections.get(socket)
+    const socket_generator = socket_item.generator
+    let message
+
+    if (socket_item.key_generated) {
+        message = JSON.parse(decrypt(data.toString(), socket_item.generator.session_key))
+    } else {
+        message = JSON.parse(data.toString())
+    }
+
+    switch (message.type) {
+        case 'msg':
+            this.localChatStore.push(message.body)
+            Array.from(this.connections.keys()).forEach((i: any) => {
+                if (i != socket) {
+                    i.write(encrypt(JSON.stringify({type: 'msg', data: message.body}), this.connections.get(i).generator.session_key))
+                }
+            })
+            break;
+        case 'public_key_request':
+            const server_random = this.manager.getServer()
+
+            socket_generator.setClient(message.body)
+            socket_generator.setServer(server_random)
+
+            socket.write(JSON.stringify({type: 'public_key_response', body: [this.manager.publicKey, server_random]}))
+            break;
+        case 'master_key_response':
+            socket_generator.setMaster(message.body[0], this.manager.privateKey)
+            socket_generator.generateSession()
+            socket_item.name = message.body[1]
+            socket_item.key_generated = true
+
+            socket.write(JSON.stringify({type: 'finished'}))
+            break;
+        case 'finished':
+            socket_item.name = message.body
+            socket.write(encrypt(JSON.stringify({type: 'history', body: this.localChatStore.getChat()}), socket_generator.session_key))
+            this.localChatStore.push(['[SERVER]', message.body + ' connected to server'])
+
+            Array.from(this.connections.keys()).forEach((i: any) => {
+                if (i != socket) {
+                    i.write(
+                        encrypt(JSON.stringify({type: 'msg', data: ['[SERVER]', message.body + ' connected to server']}), 
+                        this.connections.get(i).generator.session_key)
+                    )
+                }
+            })
+            break;
+    }
+}
+
+export { processMessage }

package/server/handlers/setupSocket.ts

@@ -0,0 +1,26 @@
+import { SessionManager } from "../../security/sessionManager"
+import { encrypt, decrypt } from "../../utils/edUtils"
+import { Server } from "../serverInstance"
+import net from 'net'
+
+function setupSocket(this: Server, socket: net.Socket, cb: Function) {
+    this.connections.set(socket, {name: null, generator: new SessionManager(), key_generated: false})
+
+    socket.on('close', () => {
+        let body = ['[SERVER]', this.connections.get(socket).name + ' disconnected from server']
+        this.localChatStore.push(body)
+
+        Array.from(this.connections.keys()).forEach((i: any) => {
+            i.write(encrypt(JSON.stringify({type: 'msg', data: body}), this.connections.get(i).generator.session_key))
+        })
+        this.connections.delete(socket)
+    })
+
+    socket.on("error", () => {}) 
+
+    socket.on('data', (data: any) => {
+        cb(socket, data)
+    })
+}
+
+export { setupSocket }

package/server/serverInstance.ts

@@ -0,0 +1,25 @@
+import net from 'net'
+import { SessionManager } from '../security/sessionManager'
+import { LocalChatStore } from '../utils/localChatStore'
+import { processMessage } from "./handlers/processMessage"
+import { setupSocket } from "./handlers/setupSocket"
+
+export class Server {
+    localChatStore: LocalChatStore
+    server: net.Server
+    manager: SessionManager
+    connections: Map<any, any>
+
+    constructor(limit=100, port=3000) {
+        this.localChatStore = new LocalChatStore(100)
+        this.manager = new SessionManager()
+        this.connections = new Map()
+        this.server = net.createServer()
+
+        this.server.on("connection", (socket) => {
+            setupSocket.call(this, socket, processMessage.bind(this))
+        })
+
+        this.server.listen(port)
+    }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "commonjs",
+    "rootDir": "./",
+    "outDir": "./build",
+    "sourceMap": false,
+    "declaration": false,
+    "declarationMap": false,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+  },
+  "exclude": ["node_modules", "build"]
+}

package/utils/edUtils.ts

@@ -0,0 +1,37 @@
+import crypto from "crypto"
+
+function formatKey(key: string) {
+    if (key.length > 32) {
+        key = key.slice(0, 32)
+    } else if (key.length < 32) {
+        key += Array.from({length: 32 - key.length}, () => 0).join('')
+    }
+
+    return key
+}
+
+function encrypt(value: string, key: string) {
+    key = formatKey(key)
+
+    const iv = Buffer.alloc(16, 0);
+    const cipher = crypto.createCipheriv("aes-256-cbc", key, iv)
+
+    let encrypted = cipher.update(value, "utf-8", "hex")
+    encrypted += cipher.final("hex")
+
+    return encrypted
+}
+
+function decrypt(value: string, key: string) {
+    key = formatKey(key)  
+
+    const iv = Buffer.alloc(16, 0);
+    const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv)
+
+    let decrypted = decipher.update(value, "hex", "utf-8")
+    decrypted += decipher.final("utf-8")
+
+    return decrypted
+}
+
+export { encrypt, decrypt }

package/utils/genNameAlias.ts

@@ -0,0 +1,7 @@
+import crypto from "crypto"
+
+function genName() {
+    return crypto.randomBytes(8).toString("hex")
+}
+
+export { genName }

package/utils/localChatStore.ts

@@ -0,0 +1,20 @@
+export class LocalChatStore {
+    chat: any
+    limit: number
+
+    constructor(limit: number) {
+        this.chat = []
+        this.limit = limit
+    }
+
+    push(message: any) {
+        if (this.chat.length >= this.limit) {
+            this.chat.splice(0, 1)
+        }
+        this.chat.push(message)
+    }
+
+    getChat() {
+        return this.chat
+    }
+}