bedrock-portal-nethernet 1.0.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -0,0 +1,12 @@
+# BedrockPortalNethernet
+[![NPM version](https://img.shields.io/npm/v/bedrock-portal.svg)](http://npmjs.com/package/bedrock-portal-nethernet)
+[![Discord](https://img.shields.io/badge/chat-on%20discord-brightgreen.svg)](https://discord.gg/KTyd9HWuBD)
+
+A simple server implementation for the Bedrock Edition Nethernet protocol used by [BedrockPortal](https://github.com/LucienHH/bedrock-portal). Join our [Discord](https://discord.com/invite/KTyd9HWuBD) for support.
+
+Based on bedrock-protocol but stripped down to only the necessary components for the Nethernet protocol.
+
+## Installation
+```shell
+npm install bedrock-portal-nethernet
+```

package/dist/datatypes/compiler-minecraft.d.ts

@@ -0,0 +1,4 @@
+import { Read } from "./varlong";
+import { Write } from "./varlong";
+import { SizeOf } from "./varlong";
+export { Read, Write, SizeOf };

package/dist/datatypes/compiler-minecraft.js

@@ -0,0 +1,224 @@
+"use strict";
+/* eslint-disable */
+const UUID = require('uuid-1345');
+const minecraft = require('./minecraft');
+const { Read, Write, SizeOf } = require('./varlong');
+/**
+ * UUIDs
+ */
+Read.uuid = ['native', (buffer, offset) => {
+        return {
+            value: UUID.stringify(buffer.slice(offset, 16 + offset)),
+            size: 16
+        };
+    }];
+Write.uuid = ['native', (value, buffer, offset) => {
+        const buf = UUID.parse(value);
+        buf.copy(buffer, offset);
+        return offset + 16;
+    }];
+SizeOf.uuid = ['native', 16];
+/**
+ * Rest of buffer
+ */
+Read.restBuffer = ['native', (buffer, offset) => {
+        return {
+            value: buffer.slice(offset),
+            size: buffer.length - offset
+        };
+    }];
+Write.restBuffer = ['native', (value, buffer, offset) => {
+        value.copy(buffer, offset);
+        return offset + value.length;
+    }];
+SizeOf.restBuffer = ['native', (value) => {
+        return value.length;
+    }];
+/**
+ * Encapsulated data with length prefix
+ */
+Read.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+        return compiler.wrapCode(`
+  const payloadSize = ${compiler.callType(lengthType, 'offset')}
+  const { value, size } = ctx.${type}(buffer, offset + payloadSize.size)
+  return { value, size: size + payloadSize.size }
+`.trim());
+    }];
+Write.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+        return compiler.wrapCode(`
+  const buf = Buffer.allocUnsafe(buffer.length - offset)
+  const payloadSize = (ctx.${type})(value, buf, 0)
+  let size = (ctx.${lengthType})(payloadSize, buffer, offset)
+  size += buf.copy(buffer, size, 0, payloadSize)
+  return size
+`.trim());
+    }];
+SizeOf.encapsulated = ['parametrizable', (compiler, { lengthType, type }) => {
+        return compiler.wrapCode(`
+    const payloadSize = (ctx.${type})(value)
+    return (ctx.${lengthType})(payloadSize) + payloadSize
+`.trim());
+    }];
+/**
+ * Read NBT until end of buffer or \0
+ */
+Read.nbtLoop = ['context', (buffer, offset) => {
+        const values = [];
+        while (buffer[offset] != 0) {
+            const n = ctx.nbt(buffer, offset);
+            values.push(n.value);
+            offset += n.size;
+        }
+        return { value: values, size: buffer.length - offset };
+    }];
+Write.nbtLoop = ['context', (value, buffer, offset) => {
+        for (const val of value) {
+            offset = ctx.nbt(val, buffer, offset);
+        }
+        buffer.writeUint8(0, offset);
+        return offset + 1;
+    }];
+SizeOf.nbtLoop = ['context', (value, buffer, offset) => {
+        let size = 1;
+        for (const val of value) {
+            size += ctx.nbt(val, buffer, offset);
+        }
+        return size;
+    }];
+/**
+ * Read rotation float encoded as a byte
+ */
+Read.byterot = ['context', (buffer, offset) => {
+        const val = buffer.readUint8(offset);
+        return { value: (val * (360 / 256)), size: 1 };
+    }];
+Write.byterot = ['context', (value, buffer, offset) => {
+        const val = (value / (360 / 256));
+        buffer.writeUint8(val, offset);
+        return offset + 1;
+    }];
+SizeOf.byterot = ['context', (value, buffer, offset) => {
+        return 1;
+    }];
+/**
+ * NBT
+ */
+Read.nbt = ['native', minecraft.nbt[0]];
+Write.nbt = ['native', minecraft.nbt[1]];
+SizeOf.nbt = ['native', minecraft.nbt[2]];
+Read.lnbt = ['native', minecraft.lnbt[0]];
+Write.lnbt = ['native', minecraft.lnbt[1]];
+SizeOf.lnbt = ['native', minecraft.lnbt[2]];
+/**
+ * Bits
+ */
+Read.bitflags = ['parametrizable', (compiler, { type, flags, shift, big }) => {
+        let fstr = JSON.stringify(flags);
+        if (Array.isArray(flags)) {
+            fstr = '{';
+            flags.map((v, k) => fstr += `"${v}": ${big ? 1n << BigInt(k) : 1 << k}` + (big ? 'n,' : ','));
+            fstr += '}';
+        }
+        else if (shift) {
+            fstr = '{';
+            for (const key in flags)
+                fstr += `"${key}": ${1 << flags[key]},`;
+            fstr += '}';
+        }
+        return compiler.wrapCode(`
+    const { value: _value, size } = ${compiler.callType(type, 'offset')}
+    const value = { _value }
+    const flags = ${fstr}
+    for (const key in flags) {
+      value[key] = (_value & flags[key]) == flags[key]
+    }
+    return { value, size }
+  `.trim());
+    }];
+Write.bitflags = ['parametrizable', (compiler, { type, flags, shift, big }) => {
+        let fstr = JSON.stringify(flags);
+        if (Array.isArray(flags)) {
+            fstr = '{';
+            flags.map((v, k) => fstr += `"${v}": ${big ? 1n << BigInt(k) : 1 << k}` + (big ? 'n,' : ','));
+            fstr += '}';
+        }
+        else if (shift) {
+            fstr = '{';
+            for (const key in flags)
+                fstr += `"${key}": ${1 << flags[key]},`;
+            fstr += '}';
+        }
+        return compiler.wrapCode(`
+    const flags = ${fstr}
+    let val = value._value ${big ? '|| 0n' : ''}
+    for (const key in flags) {
+      if (value[key]) val |= flags[key]
+    }
+    return (ctx.${type})(val, buffer, offset)
+  `.trim());
+    }];
+SizeOf.bitflags = ['parametrizable', (compiler, { type, flags, shift, big }) => {
+        let fstr = JSON.stringify(flags);
+        if (Array.isArray(flags)) {
+            fstr = '{';
+            flags.map((v, k) => fstr += `"${v}": ${big ? 1n << BigInt(k) : 1 << k}` + (big ? 'n,' : ','));
+            fstr += '}';
+        }
+        else if (shift) {
+            fstr = '{';
+            for (const key in flags)
+                fstr += `"${key}": ${1 << flags[key]},`;
+            fstr += '}';
+        }
+        return compiler.wrapCode(`
+    const flags = ${fstr}
+    let val = value._value ${big ? '|| 0n' : ''}
+    for (const key in flags) {
+      if (value[key]) val |= flags[key]
+    }
+    return (ctx.${type})(val)
+  `.trim());
+    }];
+/**
+ * Command Packet
+ * - used for determining the size of the following enum
+ */
+Read.enum_size_based_on_values_len = ['parametrizable', (compiler) => {
+        return compiler.wrapCode(js(() => {
+            if (values_len <= 0xff)
+                return { value: 'byte', size: 0 };
+            if (values_len <= 0xffff)
+                return { value: 'short', size: 0 };
+            if (values_len <= 0xffffff)
+                return { value: 'int', size: 0 };
+        }));
+    }];
+Write.enum_size_based_on_values_len = ['parametrizable', (compiler) => {
+        return str(() => {
+            if (value.values_len <= 0xff)
+                _enum_type = 'byte';
+            else if (value.values_len <= 0xffff)
+                _enum_type = 'short';
+            else if (value.values_len <= 0xffffff)
+                _enum_type = 'int';
+            return offset;
+        });
+    }];
+SizeOf.enum_size_based_on_values_len = ['parametrizable', (compiler) => {
+        return str(() => {
+            if (value.values_len <= 0xff)
+                _enum_type = 'byte';
+            else if (value.values_len <= 0xffff)
+                _enum_type = 'short';
+            else if (value.values_len <= 0xffffff)
+                _enum_type = 'int';
+            return 0;
+        });
+    }];
+function js(fn) {
+    return fn.toString().split('\n').slice(1, -1).join('\n').trim();
+}
+function str(fn) {
+    return fn.toString() + ')();(()=>{}';
+}
+module.exports = { Read, Write, SizeOf };

package/dist/datatypes/minecraft.d.ts

@@ -0,0 +1,15 @@
+declare function writeUUID(value: any, buffer: any, offset: any): any;
+declare function writeNbt(value: any, buffer: any, offset: any): any;
+declare function writeNbtLE(value: any, buffer: any, offset: any): any;
+declare function writeEntityMetadata(value: any, buffer: any, offset: any, _ref2: any): any;
+declare function writeIpAddress(value: any, buffer: any, offset: any): any;
+declare function writeEndOfArray(value: any, buffer: any, offset: any, typeArgs: any): any;
+export let uuid: (number | typeof writeUUID)[];
+export let nbt: (typeof writeNbt)[];
+export let lnbt: (typeof writeNbtLE)[];
+export let entityMetadataLoop: (typeof writeEntityMetadata)[];
+export let ipAddress: (number | typeof writeIpAddress)[];
+export let endOfArray: (typeof writeEndOfArray)[];
+export let zigzag32: any;
+export let zigzag64: any;
+export {};

package/dist/datatypes/minecraft.js

@@ -0,0 +1,146 @@
+"use strict";
+/* eslint-disable */
+const nbt = require('prismarine-nbt');
+const UUID = require('uuid-1345');
+const protoLE = nbt.protos.little;
+const protoLEV = nbt.protos.littleVarint;
+// TODO: deal with this:
+const zigzag = require('prismarine-nbt/zigzag');
+function readUUID(buffer, offset) {
+    if (offset + 16 > buffer.length) {
+        throw new PartialReadError();
+    }
+    return {
+        value: UUID.stringify(buffer.slice(offset, 16 + offset)),
+        size: 16
+    };
+}
+function writeUUID(value, buffer, offset) {
+    const buf = UUID.parse(value);
+    buf.copy(buffer, offset);
+    return offset + 16;
+}
+// Little Endian + varints
+function readNbt(buffer, offset) {
+    return protoLEV.read(buffer, offset, 'nbt');
+}
+function writeNbt(value, buffer, offset) {
+    return protoLEV.write(value, buffer, offset, 'nbt');
+}
+function sizeOfNbt(value) {
+    return protoLEV.sizeOf(value, 'nbt');
+}
+// Little Endian
+function readNbtLE(buffer, offset) {
+    const r = protoLE.read(buffer, offset, 'nbt');
+    // End size is 3 for some reason
+    if (r.value.type === 'end')
+        return { value: r.value, size: 1 };
+    return r;
+}
+function writeNbtLE(value, buffer, offset) {
+    if (value.type === 'end') {
+        buffer.writeInt8(0, offset);
+        return offset + 1;
+    }
+    return protoLE.write(value, buffer, offset, 'nbt');
+}
+function sizeOfNbtLE(value) {
+    if (value.type === 'end')
+        return 1;
+    return protoLE.sizeOf(value, 'nbt');
+}
+function readEntityMetadata(buffer, offset, _ref) {
+    const type = _ref.type;
+    const endVal = _ref.endVal;
+    let cursor = offset;
+    const metadata = [];
+    let item;
+    while (true) {
+        if (offset + 1 > buffer.length)
+            throw new PartialReadError();
+        item = buffer.readUInt8(cursor);
+        if (item === endVal) {
+            return {
+                value: metadata,
+                size: cursor + 1 - offset
+            };
+        }
+        const results = this.read(buffer, cursor, type, {});
+        metadata.push(results.value);
+        cursor += results.size;
+    }
+}
+function writeEntityMetadata(value, buffer, offset, _ref2) {
+    const type = _ref2.type;
+    const endVal = _ref2.endVal;
+    const self = this;
+    value.forEach(function (item) {
+        offset = self.write(item, buffer, offset, type, {});
+    });
+    buffer.writeUInt8(endVal, offset);
+    return offset + 1;
+}
+function sizeOfEntityMetadata(value, _ref3) {
+    const type = _ref3.type;
+    let size = 1;
+    for (let i = 0; i < value.length; ++i) {
+        size += this.sizeOf(value[i], type, {});
+    }
+    return size;
+}
+function readIpAddress(buffer, offset) {
+    const address = buffer[offset] + '.' + buffer[offset + 1] + '.' + buffer[offset + 2] + '.' + buffer[offset + 3];
+    return {
+        size: 4,
+        value: address
+    };
+}
+function writeIpAddress(value, buffer, offset) {
+    const address = value.split('.');
+    address.forEach(function (b) {
+        buffer[offset] = parseInt(b);
+        offset++;
+    });
+    return offset;
+}
+function readEndOfArray(buffer, offset, typeArgs) {
+    const type = typeArgs.type;
+    let cursor = offset;
+    const elements = [];
+    while (cursor < buffer.length) {
+        const results = this.read(buffer, cursor, type, {});
+        elements.push(results.value);
+        cursor += results.size;
+    }
+    return {
+        value: elements,
+        size: cursor - offset
+    };
+}
+function writeEndOfArray(value, buffer, offset, typeArgs) {
+    const type = typeArgs.type;
+    const self = this;
+    value.forEach(function (item) {
+        offset = self.write(item, buffer, offset, type, {});
+    });
+    return offset;
+}
+function sizeOfEndOfArray(value, typeArgs) {
+    const type = typeArgs.type;
+    let size = 0;
+    for (let i = 0; i < value.length; ++i) {
+        size += this.sizeOf(value[i], type, {});
+    }
+    return size;
+}
+module.exports = {
+    uuid: [readUUID, writeUUID, 16],
+    nbt: [readNbt, writeNbt, sizeOfNbt],
+    lnbt: [readNbtLE, writeNbtLE, sizeOfNbtLE],
+    entityMetadataLoop: [readEntityMetadata, writeEntityMetadata, sizeOfEntityMetadata],
+    ipAddress: [readIpAddress, writeIpAddress, 4],
+    endOfArray: [readEndOfArray, writeEndOfArray, sizeOfEndOfArray],
+    zigzag32: zigzag.interpret.zigzag32,
+    zigzag64: zigzag.interpret.zigzag64
+};

package/dist/datatypes/util.d.ts

@@ -0,0 +1,7 @@
+export declare function getFiles(dir: string): string[];
+export declare function sleep(ms: number): Promise<unknown>;
+export declare function waitFor(cb: (resolve: (value?: any) => void, reject: (reason?: any) => void) => void, withTimeout: number, onTimeout: () => Promise<void>): Promise<unknown>;
+export declare function serialize(obj?: {}, fmt?: string | number): string;
+export declare function uuidFrom(string: string): string;
+export declare function nextUUID(): string;
+export declare const isDebug: boolean | undefined;

package/dist/datatypes/util.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebug = void 0;
+exports.getFiles = getFiles;
+exports.sleep = sleep;
+exports.waitFor = waitFor;
+exports.serialize = serialize;
+exports.uuidFrom = uuidFrom;
+exports.nextUUID = nextUUID;
+const fs_1 = __importDefault(require("fs"));
+const uuid_1345_1 = __importDefault(require("uuid-1345"));
+function getFiles(dir) {
+    let results = [];
+    const list = fs_1.default.readdirSync(dir);
+    list.forEach((file) => {
+        file = dir + '/' + file;
+        const stat = fs_1.default.statSync(file);
+        if (stat && stat.isDirectory()) {
+            results = results.concat(getFiles(file));
+        }
+        else {
+            results.push(file);
+        }
+    });
+    return results;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+async function waitFor(cb, withTimeout, onTimeout) {
+    let t;
+    const ret = await Promise.race([
+        new Promise((resolve, reject) => cb(resolve, reject)),
+        new Promise(resolve => { t = setTimeout(() => resolve('timeout'), withTimeout); }),
+    ]);
+    clearTimeout(t);
+    if (ret === 'timeout')
+        await onTimeout();
+    return ret;
+}
+function serialize(obj = {}, fmt) {
+    return JSON.stringify(obj, (k, v) => typeof v === 'bigint' ? v.toString() : v, fmt);
+}
+function uuidFrom(string) {
+    return uuid_1345_1.default.v3({ namespace: '6ba7b811-9dad-11d1-80b4-00c04fd430c8', name: string });
+}
+function nextUUID() {
+    return uuidFrom(Date.now().toString());
+}
+exports.isDebug = process.env.DEBUG?.includes('bedrock-portal-nethernet');

package/dist/datatypes/varlong.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Reads a 64-bit VarInt as a BigInt
+ */
+declare function readVarLong(buffer: any, offset: any): {
+    value: bigint;
+    size: number;
+};
+/**
+ * Writes a zigzag encoded 64-bit VarInt as a BigInt
+ */
+declare function writeVarLong(value: any, buffer: any, offset: any): any;
+declare function sizeOfVarLong(value: any): number;
+export namespace Read {
+    let varint64: (string | typeof readVarLong)[];
+}
+export namespace Write {
+    let varint64_1: (string | typeof writeVarLong)[];
+    export { varint64_1 as varint64 };
+}
+export namespace SizeOf {
+    let varint64_2: (string | typeof sizeOfVarLong)[];
+    export { varint64_2 as varint64 };
+}
+export {};

package/dist/datatypes/varlong.js

@@ -0,0 +1,67 @@
+"use strict";
+function sizeOfVarLong(value) {
+    if (typeof value.valueOf() === 'object') {
+        value = (BigInt(value[0]) << 32n) | BigInt(value[1]);
+    }
+    else if (typeof value !== 'bigint') {
+        value = BigInt(value);
+    }
+    let cursor = 0;
+    while (value > 127n) {
+        value >>= 7n;
+        cursor++;
+    }
+    return cursor + 1;
+}
+/**
+ * Reads a 64-bit VarInt as a BigInt
+ */
+function readVarLong(buffer, offset) {
+    let result = BigInt(0);
+    let shift = 0n;
+    let cursor = offset;
+    let size = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        if (cursor + 1 > buffer.length) {
+            throw new Error('unexpected buffer end');
+        }
+        const b = buffer.readUInt8(cursor);
+        result |= (BigInt(b) & 0x7fn) << shift; // Add the bits to our number, except MSB
+        cursor++;
+        if (!(b & 0x80)) { // If the MSB is not set, we return the number
+            size = cursor - offset;
+            break;
+        }
+        shift += 7n; // we only have 7 bits, MSB being the return-trigger
+        if (shift > 63n)
+            throw new Error(`varint is too big: ${shift}`);
+    }
+    return { value: result, size };
+}
+/**
+ * Writes a zigzag encoded 64-bit VarInt as a BigInt
+ */
+function writeVarLong(value, buffer, offset) {
+    // if an array, turn it into a BigInt
+    if (typeof value.valueOf() === 'object') {
+        value = BigInt.asIntN(64, (BigInt(value[0]) << 32n)) | BigInt(value[1]);
+    }
+    else if (typeof value !== 'bigint') {
+        value = BigInt(value);
+    }
+    let cursor = 0;
+    while (value > 127n) { // keep writing in 7 bit slices
+        const num = Number(value & 0xffn);
+        buffer.writeUInt8(num | 0x80, offset + cursor);
+        cursor++;
+        value >>= 7n;
+    }
+    buffer.writeUInt8(Number(value), offset + cursor);
+    return offset + cursor + 1;
+}
+module.exports = {
+    Read: { varint64: ['native', readVarLong] },
+    Write: { varint64: ['native', writeVarLong] },
+    SizeOf: { varint64: ['native', sizeOfVarLong] },
+};

package/dist/handshake/constants.d.ts

@@ -0,0 +1 @@
+export declare const PUBLIC_KEY = "MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp";

package/dist/handshake/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLIC_KEY = void 0;
+exports.PUBLIC_KEY = 'MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAECRXueJeTDqNRRgJi/vlRufByu/2G0i2Ebt6YMar5QX/R0DIIyrJMcUpruK4QveTfJSTp3Shlq4Gk34cD/4GUWwkv0DVuzeuB+tXija7HBxii03NHDbPAD0AKnLr2wdAp';

package/dist/handshake/keyExchange.d.ts

@@ -0,0 +1,2 @@
+import { Player } from '../serverPlayer';
+export declare function KeyExchange(client: Player): void;

package/dist/handshake/keyExchange.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyExchange = KeyExchange;
+const jsonwebtoken_1 = require("jsonwebtoken");
+const crypto_1 = require("crypto");
+const serverPlayer_1 = require("../serverPlayer");
+const debug = require('debug')('bedrock-portal-nethernet');
+const SALT = '🧂';
+const curve = 'secp384r1';
+const pem = { format: 'pem', type: 'sec1' };
+const der = { format: 'der', type: 'spki' };
+function KeyExchange(client) {
+    // Generate a key pair at program start up
+    client.ecdhKeyPair = (0, crypto_1.generateKeyPairSync)('ec', { namedCurve: curve });
+    client.publicKeyDER = client.ecdhKeyPair.publicKey.export(der);
+    client.privateKeyPEM = client.ecdhKeyPair.privateKey.export(pem);
+    client.clientX509 = client.publicKeyDER.toString('base64');
+    function startClientboundEncryption(publicKey) {
+        debug('[encrypt] Client pub key base64: ', publicKey);
+        // const pubKeyDer = crypto.createPublicKey({ key: Buffer.from(publicKey.key, 'base64'), ...der })
+        // Shared secret from the client's public key + our private key
+        // client.sharedSecret = crypto.diffieHellman({ privateKey: client.ecdhKeyPair.privateKey, publicKey: pubKeyDer })
+        // Secret hash we use for packet encryption:
+        // From the public key of the remote and the private key
+        // of the local, a shared secret is generated using ECDH.
+        // The secret key bytes are then computed as
+        // sha256(server_token + shared_secret). These secret key
+        //  bytes are 32 bytes long.
+        // const secretHash = crypto.createHash('sha256')
+        // secretHash.update(SALT)
+        // secretHash.update(client.sharedSecret)
+        const token = (0, jsonwebtoken_1.sign)({
+            salt: toBase64(SALT),
+            signedToken: client.clientX509,
+        }, client.ecdhKeyPair.privateKey, { algorithm: 'ES384', header: { x5u: client.clientX509, alg: 'ES384' } });
+        client.write('server_to_client_handshake', { token });
+        // client.secretKeyBytes = secretHash.digest()
+        // // The encryption scheme is AES/CFB8/NoPadding with the
+        // // secret key being the result of the sha256 above and
+        // // the IV being the first 16 bytes of this secret key.
+        // const initial = client.secretKeyBytes.slice(0, 16)
+        // client.startEncryption(initial)
+    }
+    function startServerboundEncryption(token) {
+        debug('[encrypt] Starting serverbound encryption', token);
+        const jwt = token?.token;
+        if (!jwt) {
+            throw Error('Server did not return a valid JWT, cannot start encryption');
+        }
+        // No verification here, not needed
+        const [header, payload] = jwt.split('.').map(k => Buffer.from(k, 'base64'));
+        const head = JSON.parse(String(header));
+        const body = JSON.parse(String(payload));
+        const pubKeyDer = (0, crypto_1.createPublicKey)({ key: Buffer.from(head.x5u, 'base64'), format: 'der', type: 'spki' });
+        // Shared secret from the client's public key + our private key
+        client.sharedSecret = (0, crypto_1.diffieHellman)({ privateKey: client.ecdhKeyPair.privateKey, publicKey: pubKeyDer });
+        const salt = Buffer.from(body.salt, 'base64');
+        const secretHash = (0, crypto_1.createHash)('sha256');
+        secretHash.update(salt);
+        secretHash.update(client.sharedSecret);
+        client.secretKeyBytes = secretHash.digest();
+        // const iv = client.secretKeyBytes.slice(0, 16)
+        // client.startEncryption(iv)
+        // It works! First encrypted packet :)
+        client.write('client_to_server_handshake', {});
+        client.emit('join');
+        client.status = serverPlayer_1.ClientStatus.Initializing;
+    }
+    client.on('server.client_handshake', startClientboundEncryption);
+    client.on('client.server_handshake', startServerboundEncryption);
+}
+function toBase64(string) {
+    return Buffer.from(string).toString('base64');
+}

package/dist/handshake/loginVerify.d.ts

@@ -0,0 +1,3 @@
+import { Player } from '../serverPlayer';
+declare const _default: (client: Player) => void;
+export default _default;