cubyz-node-client 1.1.0 → 1.3.0

package/dist/connection.js

@@ -2,15 +2,18 @@ import { Buffer } from "node:buffer";
 import { randomInt } from "node:crypto";
 import dgram from "node:dgram";
 import { EventEmitter } from "node:events";
-import { readInt32BE, writeInt32BE } from "./binary.js";
+import { loadOrCreateIdentity, signEd25519, signMlDsa44, signP256, } from "./authentication.js";
+import { decodeVarInt, readInt32BE, writeInt32BE } from "./binary.js";
 import { prepareChatMessage } from "./chatFormat.js";
-import { DEG_TO_RAD, LOG_LEVEL_ORDER, } from "./connectionTypes.js";
+import { DEG_TO_RAD, GENERIC_UPDATE_TYPE, LOG_LEVEL_ORDER, WORLD_EDIT_POSITION, } from "./connectionTypes.js";
 import { AWAITING_SERVER_TIMEOUT_MS, CHANNEL, CONFIRMATION_BATCH_SIZE, DEFAULT_VERSION, HANDSHAKE_STATE, INIT_RESEND_INTERVAL_MS, KEEP_ALIVE_INTERVAL_MS, KEEP_ALIVE_TIMEOUT_MS, PROTOCOL, } from "./constants.js";
 import { parseEntityPositionPacket } from "./entityParser.js";
 import { buildHandshakePayload, parseHandshake, randomSequence, } from "./handshakeUtils.js";
 import { parseChannelPacket, ReceiveChannel } from "./receiveChannel.js";
+import { SecureChannelHandler } from "./secureChannel.js";
 import { SendChannel } from "./sendChannel.js";
 import { parseZon } from "./zon.js";
+export { GAMEMODE } from "./connectionTypes.js";
 export class CubyzConnection extends EventEmitter {
     host;
     port;
@@ -43,9 +46,11 @@ export class CubyzConnection extends EventEmitter {
     disconnectSent = false;
     disconnectEmitted = false;
     initSent = false;
-    handshakeQueued = false;
     awaitingServerSince = null;
-    constructor({ host, port, name, version = DEFAULT_VERSION, logger = console, logLevel = "error", }) {
+    identityFile;
+    identity = null;
+    secureChannel = null;
+    constructor({ host, port, name, version = DEFAULT_VERSION, logger = console, logLevel = "error", identityFile = "./cubyz-identity.txt", }) {
         super();
         this.host = host;
         this.port = port;
@@ -53,11 +58,12 @@ export class CubyzConnection extends EventEmitter {
         this.version = version;
         this.baseLogger = logger ?? console;
         this.logLevel = (logLevel in LOG_LEVEL_ORDER ? logLevel : "error");
+        this.identityFile = identityFile;
         this.socket = dgram.createSocket("udp4");
         this.connectionId = BigInt.asIntN(64, (BigInt(Date.now()) << 20n) | BigInt(randomInt(0, 0xfffff)));
         this.sendChannels = {
             [CHANNEL.LOSSY]: new SendChannel(CHANNEL.LOSSY, randomSequence()),
-            [CHANNEL.FAST]: new SendChannel(CHANNEL.FAST, randomSequence()),
+            [CHANNEL.SECURE]: new SendChannel(CHANNEL.SECURE, randomSequence()),
             [CHANNEL.SLOW]: new SendChannel(CHANNEL.SLOW, randomSequence()),
         };
         this.socket.on("message", (msg) => {
@@ -113,6 +119,8 @@ export class CubyzConnection extends EventEmitter {
         return super.emit(event, ...args);
     }
     async start() {
+        this.identity = await loadOrCreateIdentity(this.identityFile);
+        this.log("info", `Loaded identity from ${this.identityFile}`);
         await new Promise((resolve, reject) => {
             const onError = (err) => {
                 this.socket.off("listening", onListening);
@@ -192,6 +200,10 @@ export class CubyzConnection extends EventEmitter {
     }
     flushSendQueues(now) {
         for (const channel of Object.values(this.sendChannels)) {
+            // The SECURE channel is driven by SecureChannelHandler; skip normal queuing.
+            if (channel.channelId === CHANNEL.SECURE) {
+                continue;
+            }
             if (!channel.hasWork()) {
                 continue;
             }
@@ -241,28 +253,69 @@ export class CubyzConnection extends EventEmitter {
         payload[0] = CHANNEL.INIT;
         payload.writeBigInt64BE(this.connectionId, 1);
         writeInt32BE(payload, 9, this.sendChannels[CHANNEL.LOSSY].initialSequence);
-        writeInt32BE(payload, 13, this.sendChannels[CHANNEL.FAST].initialSequence);
+        writeInt32BE(payload, 13, this.sendChannels[CHANNEL.SECURE].initialSequence);
         writeInt32BE(payload, 17, this.sendChannels[CHANNEL.SLOW].initialSequence);
         this.socket.send(payload, this.port, this.host);
         this.initSent = true;
     }
-    sendInitAck() {
+    sendInitAck(onSent) {
         const buffer = Buffer.alloc(1 + 8);
         buffer[0] = CHANNEL.INIT;
         buffer.writeBigInt64BE(this.connectionId, 1);
-        this.socket.send(buffer, this.port, this.host);
+        this.socket.send(buffer, this.port, this.host, (err) => {
+            if (err) {
+                this.log("error", "Failed to send init ack:", err);
+            }
+            onSent?.();
+        });
     }
-    ensureReceiveChannels(lossyStart, fastStart, slowStart) {
+    ensureReceiveChannels(lossyStart, secureStart, slowStart) {
         if (!this.receiveChannels.has(CHANNEL.LOSSY)) {
             this.receiveChannels.set(CHANNEL.LOSSY, new ReceiveChannel(CHANNEL.LOSSY, lossyStart));
         }
-        if (!this.receiveChannels.has(CHANNEL.FAST)) {
-            this.receiveChannels.set(CHANNEL.FAST, new ReceiveChannel(CHANNEL.FAST, fastStart));
+        if (!this.receiveChannels.has(CHANNEL.SECURE)) {
+            const secureRecv = new ReceiveChannel(CHANNEL.SECURE, secureStart);
+            // Route raw bytes from the SECURE channel into the TLS handler.
+            secureRecv.rawBytesCallback = (data) => {
+                this.secureChannel?.feedRawBytes(data);
+            };
+            this.receiveChannels.set(CHANNEL.SECURE, secureRecv);
         }
         if (!this.receiveChannels.has(CHANNEL.SLOW)) {
             this.receiveChannels.set(CHANNEL.SLOW, new ReceiveChannel(CHANNEL.SLOW, slowStart));
         }
     }
+    setupSecureChannel() {
+        if (this.secureChannel !== null) {
+            return;
+        }
+        const handler = new SecureChannelHandler({
+            socket: this.socket,
+            host: this.host,
+            port: this.port,
+            channelId: CHANNEL.SECURE,
+            mtu: 548,
+            initialSendSeq: this.sendChannels[CHANNEL.SECURE].initialSequence,
+        });
+        handler.onError = (err) => {
+            this.log("error", "Secure channel error:", err);
+        };
+        handler.onSecureConnect = (_verificationData) => {
+            this.log("debug", "TLS handshake complete, sending userData");
+            if (!this.identity) {
+                this.log("error", "No identity loaded before TLS handshake completed");
+                return;
+            }
+            const payload = buildHandshakePayload(this.name, this.version, this.identity);
+            handler.sendMessage(PROTOCOL.HANDSHAKE, payload);
+        };
+        handler.onMessage = (msg) => {
+            this.handleProtocol(CHANNEL.SECURE, msg.protocolId, msg.payload).catch((err) => {
+                this.log("error", `Secure protocol ${msg.protocolId} failed:`, err);
+            });
+        };
+        this.secureChannel = handler;
+    }
     handlePacket(buffer) {
         if (!buffer || buffer.length === 0) {
             return;
@@ -301,27 +354,24 @@ export class CubyzConnection extends EventEmitter {
         const remoteId = buffer.readBigInt64BE(1);
         this.remoteConnectionId = remoteId;
         const lossyStart = readInt32BE(buffer, 9);
-        const fastStart = readInt32BE(buffer, 13);
+        const secureStart = readInt32BE(buffer, 13);
         const slowStart = readInt32BE(buffer, 17);
-        this.ensureReceiveChannels(lossyStart, fastStart, slowStart);
+        this.ensureReceiveChannels(lossyStart, secureStart, slowStart);
         if (this.state !== "connected") {
             this.state = "connected";
             this.lastInbound = Date.now();
             this.awaitingServerSince = null;
             this.log("info", "Channel handshake completed with server");
-            this.sendInitAck();
-            this.queueHandshake();
+            this.setupSecureChannel();
+            // Send the init-ACK and only start the TLS handshake once the packet
+            // has been handed to the OS, guaranteeing the server transitions to
+            // .connected before it receives the TLS ClientHello.
+            this.sendInitAck(() => {
+                this.secureChannel?.startHandshake();
+            });
             this.emit("connected");
         }
     }
-    queueHandshake() {
-        if (this.handshakeQueued) {
-            return;
-        }
-        const payload = buildHandshakePayload(this.name, this.version);
-        this.sendChannels[CHANNEL.FAST].queue(PROTOCOL.HANDSHAKE, payload);
-        this.handshakeQueued = true;
-    }
     async handleSequencedPacket(buffer) {
         const parsed = parseChannelPacket(buffer);
         const channel = this.receiveChannels.get(parsed.channelId);
@@ -357,6 +407,7 @@ export class CubyzConnection extends EventEmitter {
         }
     }
     async handleProtocol(channelId, protocolId, payload) {
+        // this.log("debug", `handleProtocol: channelId=${channelId}, protocolId=${protocolId}, payloadLen=${payload.length}`);
         switch (protocolId) {
             case PROTOCOL.HANDSHAKE:
                 await this.handleHandshake(payload);
@@ -365,10 +416,18 @@ export class CubyzConnection extends EventEmitter {
                 this.handleEntityPosition(payload);
                 this.emit("protocol", { channelId, protocolId, payload });
                 break;
+            case PROTOCOL.BLOCK_UPDATE:
+                this.handleBlockUpdate(payload);
+                this.emit("protocol", { channelId, protocolId, payload });
+                break;
             case PROTOCOL.ENTITY:
                 this.handleEntityUpdate(payload);
                 this.emit("protocol", { channelId, protocolId, payload });
                 break;
+            case PROTOCOL.GENERIC_UPDATE:
+                this.handleGenericUpdate(payload);
+                this.emit("protocol", { channelId, protocolId, payload });
+                break;
             case PROTOCOL.CHAT:
                 this.emit("chat", payload.toString("utf8"));
                 break;
@@ -379,6 +438,10 @@ export class CubyzConnection extends EventEmitter {
     async handleHandshake(payload) {
         const { state, data } = parseHandshake(payload);
         switch (state) {
+            case HANDSHAKE_STATE.SIGNATURE_REQUEST: {
+                await this.handleSignatureRequest(data);
+                break;
+            }
             case HANDSHAKE_STATE.ASSETS: {
                 // Assets are compressed with zlib's raw DEFLATE
                 // Skipping asset storage for brevity
@@ -479,6 +542,63 @@ export class CubyzConnection extends EventEmitter {
                 this.log("debug", `Unhandled handshake state ${state}`);
         }
     }
+    async handleSignatureRequest(data) {
+        if (!this.identity) {
+            this.log("error", "No identity available for signature request");
+            return;
+        }
+        if (!this.secureChannel) {
+            this.log("error", "No secure channel for signature request");
+            return;
+        }
+        const verificationData = this.secureChannel.verificationDataBuffer ?? Buffer.alloc(0);
+        // Parse signatureRequest:
+        // [varint: len of algo1 name][algo1 name bytes][varint: len of algo2 name (0 if none)][algo2 name bytes if present]
+        let offset = 0;
+        const algo1LenResult = decodeVarInt(data, offset);
+        offset += algo1LenResult.consumed;
+        const algo1Name = data
+            .slice(offset, offset + algo1LenResult.value)
+            .toString("utf8");
+        offset += algo1LenResult.value;
+        let algo2Name = "";
+        if (offset < data.length) {
+            const algo2LenResult = decodeVarInt(data, offset);
+            offset += algo2LenResult.consumed;
+            if (algo2LenResult.value > 0) {
+                algo2Name = data
+                    .slice(offset, offset + algo2LenResult.value)
+                    .toString("utf8");
+            }
+        }
+        this.log("debug", "Signature request: algo1=", algo1Name, "algo2=", algo2Name);
+        const signatureBuffers = [];
+        const identity = this.identity;
+        const signOne = async (algoName) => {
+            switch (algoName) {
+                case "ed25519":
+                    signatureBuffers.push(signEd25519(identity.keys.ed25519PrivKey, verificationData));
+                    break;
+                case "ecdsaP256Sha256":
+                    signatureBuffers.push(signP256(identity.keys.p256PrivKey, verificationData));
+                    break;
+                case "mldsa44":
+                    signatureBuffers.push(await signMlDsa44(identity.keys.mlDsa44PrivKey, verificationData));
+                    break;
+                default:
+                    this.log("warn", "Unknown signature algorithm requested:", algoName);
+            }
+        };
+        await signOne(algo1Name);
+        if (algo2Name) {
+            await signOne(algo2Name);
+        }
+        // signatureResponse format: [state byte = 3][sig1_bytes][optional sig2_bytes]
+        const statePrefix = Buffer.from([HANDSHAKE_STATE.SIGNATURE_RESPONSE]);
+        const responsePayload = Buffer.concat([statePrefix, ...signatureBuffers]);
+        this.secureChannel.sendMessage(PROTOCOL.HANDSHAKE, responsePayload);
+        this.log("debug", "Sent signature response");
+    }
     handleEntityUpdate(payload) {
         const text = payload.toString("utf8");
         let parsed;
@@ -495,8 +615,11 @@ export class CubyzConnection extends EventEmitter {
             return;
         }
         let changed = false;
-        for (const entry of parsed) {
+        let nullIndex = -1;
+        for (let i = 0; i < parsed.length; i++) {
+            const entry = parsed[i];
             if (entry === null) {
+                nullIndex = i;
                 break;
             }
             if (typeof entry === "number") {
@@ -539,24 +662,33 @@ export class CubyzConnection extends EventEmitter {
             }
             this.emitPlayers();
         }
+        // Process item drops after the null sentinel.
+        // Number entries are removals (by u16 index); object entries are additions
+        // or updates whose positions will arrive via the entityPositions protocol.
+        if (nullIndex >= 0) {
+            for (let i = nullIndex + 1; i < parsed.length; i++) {
+                const entry = parsed[i];
+                if (typeof entry === "number") {
+                    this.itemStates.delete(entry);
+                }
+                // Object entries (add/update) don't carry position data here;
+                // their positions are delivered via protocol 6 (ENTITY_POSITION).
+            }
+        }
     }
     handleEntityPosition(payload) {
         const result = parseEntityPositionPacket(payload, this.log.bind(this));
         if (!result) {
             return;
         }
-        // Update internal state with parsed entities
         this.entityStates.clear();
-        const entityStatesMap = result._entityStates;
-        for (const [id, state] of entityStatesMap) {
+        for (const [id, state] of result.entityStates) {
             this.entityStates.set(id, state);
         }
         this.itemStates.clear();
-        const itemStatesMap = result._itemStates;
-        for (const [index, state] of itemStatesMap) {
+        for (const [index, state] of result.itemStates) {
             this.itemStates.set(index, state);
         }
-        // Emit the packet without internal state maps
         const packet = {
             timestamp: result.timestamp,
             basePosition: result.basePosition,
@@ -565,6 +697,204 @@ export class CubyzConnection extends EventEmitter {
         };
         this.emit("entityPositions", packet);
     }
+    handleBlockUpdate(payload) {
+        const updates = [];
+        let offset = 0;
+        while (offset + 20 <= payload.length) {
+            const x = payload.readInt32BE(offset);
+            offset += 4;
+            const y = payload.readInt32BE(offset);
+            offset += 4;
+            const z = payload.readInt32BE(offset);
+            offset += 4;
+            const block = payload.readUInt32BE(offset);
+            offset += 4;
+            // blockEntityData length is written as usize (8 bytes, big-endian) by the Zig server.
+            if (offset + 8 > payload.length) {
+                this.log("warn", "Block update payload truncated (no room for length)");
+                break;
+            }
+            const blockEntityDataLen = Number(payload.readBigUInt64BE(offset));
+            offset += 8;
+            if (offset + blockEntityDataLen > payload.length) {
+                this.log("warn", "Block update payload truncated");
+                break;
+            }
+            const blockEntityData = payload.slice(offset, offset + blockEntityDataLen);
+            offset += blockEntityDataLen;
+            updates.push({
+                position: { x, y, z },
+                block,
+                blockEntityData,
+            });
+        }
+        if (updates.length > 0) {
+            this.emit("blockUpdate", updates);
+        }
+    }
+    handleGenericUpdate(payload) {
+        if (payload.length < 1) {
+            this.log("warn", "Generic update payload too short");
+            return;
+        }
+        const updateType = payload.readUInt8(0);
+        let offset = 1;
+        this.log("debug", `handleGenericUpdate: type=${updateType}, payloadLen=${payload.length}`);
+        try {
+            switch (updateType) {
+                case GENERIC_UPDATE_TYPE.GAMEMODE: {
+                    if (offset + 1 > payload.length) {
+                        this.log("warn", "Gamemode update payload too short");
+                        return;
+                    }
+                    const gamemode = payload.readUInt8(offset);
+                    this.log("debug", `Gamemode update: ${gamemode}`);
+                    this.emit("genericUpdate", {
+                        type: "gamemode",
+                        gamemode,
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.TELEPORT: {
+                    if (offset + 24 > payload.length) {
+                        this.log("warn", "Teleport update payload too short");
+                        return;
+                    }
+                    const x = payload.readDoubleBE(offset);
+                    offset += 8;
+                    const y = payload.readDoubleBE(offset);
+                    offset += 8;
+                    const z = payload.readDoubleBE(offset);
+                    this.emit("genericUpdate", {
+                        type: "teleport",
+                        position: { x, y, z },
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.WORLD_EDIT_POS: {
+                    if (offset + 1 > payload.length) {
+                        this.log("warn", "World edit pos update payload too short");
+                        return;
+                    }
+                    const posType = payload.readUInt8(offset);
+                    offset += 1;
+                    let position = null;
+                    if (posType === WORLD_EDIT_POSITION.SELECTED_POS1 ||
+                        posType === WORLD_EDIT_POSITION.SELECTED_POS2) {
+                        if (offset + 12 > payload.length) {
+                            this.log("warn", "World edit pos update payload too short");
+                            return;
+                        }
+                        const x = payload.readInt32BE(offset);
+                        offset += 4;
+                        const y = payload.readInt32BE(offset);
+                        offset += 4;
+                        const z = payload.readInt32BE(offset);
+                        position = { x, y, z };
+                    }
+                    this.emit("genericUpdate", {
+                        type: "worldEditPos",
+                        positionType: posType,
+                        position,
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.TIME: {
+                    if (offset + 8 > payload.length) {
+                        this.log("warn", "Time update payload too short");
+                        return;
+                    }
+                    const time = payload.readBigInt64BE(offset);
+                    this.emit("genericUpdate", {
+                        type: "time",
+                        time,
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.BIOME: {
+                    if (offset + 4 > payload.length) {
+                        this.log("warn", "Biome update payload too short");
+                        return;
+                    }
+                    const biomeId = payload.readUInt32BE(offset);
+                    this.emit("genericUpdate", {
+                        type: "biome",
+                        biomeId,
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.PARTICLES: {
+                    // [varint u16: particleIdLen][particleId][f64 x][f64 y][f64 z][u8 collides][varint u32: count][varint usize: spawnZonLen][spawnZon]
+                    const particleIdLenResult = decodeVarInt(payload, offset);
+                    offset += particleIdLenResult.consumed;
+                    const particleIdLen = particleIdLenResult.value;
+                    if (offset + particleIdLen > payload.length) {
+                        this.log("warn", "Particles update payload truncated (particleId)");
+                        return;
+                    }
+                    const particleId = payload
+                        .slice(offset, offset + particleIdLen)
+                        .toString("utf8");
+                    offset += particleIdLen;
+                    if (offset + 24 > payload.length) {
+                        this.log("warn", "Particles update payload truncated (position)");
+                        return;
+                    }
+                    const px = payload.readDoubleBE(offset);
+                    offset += 8;
+                    const py = payload.readDoubleBE(offset);
+                    offset += 8;
+                    const pz = payload.readDoubleBE(offset);
+                    offset += 8;
+                    if (offset + 1 > payload.length) {
+                        this.log("warn", "Particles update payload truncated (collides)");
+                        return;
+                    }
+                    const collides = payload.readUInt8(offset) !== 0;
+                    offset += 1;
+                    const countResult = decodeVarInt(payload, offset);
+                    offset += countResult.consumed;
+                    const count = countResult.value;
+                    const spawnZonLenResult = decodeVarInt(payload, offset);
+                    offset += spawnZonLenResult.consumed;
+                    const spawnZonLen = spawnZonLenResult.value;
+                    if (offset + spawnZonLen > payload.length) {
+                        this.log("warn", "Particles update payload truncated (spawnZon)");
+                        return;
+                    }
+                    const spawnZon = payload
+                        .slice(offset, offset + spawnZonLen)
+                        .toString("utf8");
+                    this.emit("genericUpdate", {
+                        type: "particles",
+                        particleId,
+                        position: { x: px, y: py, z: pz },
+                        collides,
+                        count,
+                        spawnZon,
+                    });
+                    break;
+                }
+                case GENERIC_UPDATE_TYPE.CLEAR: {
+                    // [u8 clearType: 0=chat]
+                    if (offset + 1 > payload.length) {
+                        this.log("warn", "Clear update payload too short");
+                        return;
+                    }
+                    const clearTypeByte = payload.readUInt8(offset);
+                    // Only clearType 0 (chat) is defined by the server.
+                    const clearType = clearTypeByte === 0 ? "chat" : "chat";
+                    this.emit("genericUpdate", { type: "clear", clearType });
+                    break;
+                }
+                default:
+                    this.log("debug", `Unknown generic update type: ${updateType}`);
+            }
+        }
+        catch (err) {
+            this.log("error", "Failed to parse generic update:", err);
+        }
+    }
     emitPlayers() {
         const players = this.getPlayers();
         this.emit("players", players);