packet-events-js 1.0.0

package/src/auth/MojangAPI.js

@@ -0,0 +1,186 @@
+import https from 'https';
+
+export class MojangAPI {
+    static SESSION_SERVER = 'sessionserver.mojang.com';
+    static API_SERVER = 'api.mojang.com';
+    
+    static async hasJoinedServer(username, serverHash, ip = null) {
+        return new Promise((resolve, reject) => {
+            let url = `/session/minecraft/hasJoined?username=${encodeURIComponent(username)}&serverId=${encodeURIComponent(serverHash)}`;
+            
+            if (ip) {
+                url += `&ip=${encodeURIComponent(ip)}`;
+            }
+            
+            const options = {
+                hostname: MojangAPI.SESSION_SERVER,
+                path: url,
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json'
+                }
+            };
+            
+            const req = https.request(options, (res) => {
+                let data = '';
+                
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 200 && data) {
+                        try {
+                            const profile = JSON.parse(data);
+                            resolve({
+                                success: true,
+                                uuid: profile.id,
+                                name: profile.name,
+                                properties: profile.properties || []
+                            });
+                        } catch (e) {
+                            reject(new Error('Invalid JSON response'));
+                        }
+                    } else if (res.statusCode === 204) {
+                        resolve({ success: false, reason: 'NOT_AUTHENTICATED' });
+                    } else {
+                        resolve({ success: false, reason: 'SERVER_ERROR', statusCode: res.statusCode });
+                    }
+                });
+            });
+            
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.end();
+        });
+    }
+    
+    static async joinServer(accessToken, selectedProfile, serverHash) {
+        return new Promise((resolve, reject) => {
+            const payload = JSON.stringify({
+                accessToken,
+                selectedProfile,
+                serverId: serverHash
+            });
+            
+            const options = {
+                hostname: MojangAPI.SESSION_SERVER,
+                path: '/session/minecraft/join',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(payload)
+                }
+            };
+            
+            const req = https.request(options, (res) => {
+                let data = '';
+                
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 204) {
+                        resolve({ success: true });
+                    } else {
+                        try {
+                            const error = JSON.parse(data);
+                            resolve({ success: false, error: error.error, message: error.errorMessage });
+                        } catch (e) {
+                            resolve({ success: false, reason: 'SERVER_ERROR' });
+                        }
+                    }
+                });
+            });
+            
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.write(payload);
+            req.end();
+        });
+    }
+    
+    static async getProfile(uuid) {
+        return new Promise((resolve, reject) => {
+            const cleanUUID = uuid.replace(/-/g, '');
+            
+            const options = {
+                hostname: MojangAPI.SESSION_SERVER,
+                path: `/session/minecraft/profile/${cleanUUID}`,
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json'
+                }
+            };
+            
+            const req = https.request(options, (res) => {
+                let data = '';
+                
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        try {
+                            resolve(JSON.parse(data));
+                        } catch (e) {
+                            reject(new Error('Invalid JSON'));
+                        }
+                    } else {
+                        resolve(null);
+                    }
+                });
+            });
+            
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    
+    static async getUUID(username) {
+        return new Promise((resolve, reject) => {
+            const options = {
+                hostname: MojangAPI.API_SERVER,
+                path: `/users/profiles/minecraft/${encodeURIComponent(username)}`,
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json'
+                }
+            };
+            
+            const req = https.request(options, (res) => {
+                let data = '';
+                
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                    if (res.statusCode === 200) {
+                        try {
+                            const profile = JSON.parse(data);
+                            resolve({
+                                uuid: profile.id,
+                                name: profile.name
+                            });
+                        } catch (e) {
+                            reject(new Error('Invalid JSON'));
+                        }
+                    } else {
+                        resolve(null);
+                    }
+                });
+            });
+            
+            req.on('error', reject);
+            req.end();
+        });
+    }
+    
+    static decodeTextures(base64Properties) {
+        try {
+            const decoded = Buffer.from(base64Properties, 'base64').toString('utf8');
+            return JSON.parse(decoded);
+        } catch (e) {
+            return null;
+        }
+    }
+}
+
+export default MojangAPI;

package/src/client/MinecraftClient.js

@@ -0,0 +1,336 @@
+import { createConnection, Socket } from 'net';
+import { createCipheriv, createDecipheriv, createHash, randomBytes, publicEncrypt } from 'crypto';
+import { EventEmitter } from '../events/EventEmitter.js';
+import { PacketManager } from '../manager/PacketManager.js';
+import { PacketRegistry, defaultRegistry } from '../protocol/packets/PacketRegistry.js';
+import { ConnectionState } from '../protocol/ConnectionState.js';
+import { PacketDirection } from '../protocol/PacketDirection.js';
+import { ProtocolVersion } from '../protocol/ProtocolVersion.js';
+import { Logger } from '../utils/Logger.js';
+import { UUID } from '../protocol/types/UUID.js';
+
+import { 
+    HandshakePacket, 
+    StatusRequestPacket, 
+    StatusResponsePacket,
+    PingPacket, 
+    PongPacket,
+    LoginStartPacket,
+    EncryptionRequestPacket,
+    EncryptionResponsePacket,
+    LoginSuccessPacket,
+    SetCompressionPacket,
+    DisconnectPacket
+} from '../protocol/packets/index.js';
+
+const logger = Logger.getLogger('MinecraftClient');
+
+export const ClientState = Object.freeze({
+    DISCONNECTED: 'DISCONNECTED',
+    CONNECTING: 'CONNECTING',
+    CONNECTED: 'CONNECTED',
+    AUTHENTICATING: 'AUTHENTICATING',
+    READY: 'READY',
+    DISCONNECTING: 'DISCONNECTING'
+});
+
+export class MinecraftClient extends EventEmitter {
+    
+    constructor(options) {
+        super();
+
+        this.host = options.host;
+        this.port = options.port || 25565;
+        this.version = options.version || ProtocolVersion.getLatest();
+        this.username = options.username || 'Player';
+        this.offline = options.offline !== false;
+        
+        this.state = ClientState.DISCONNECTED;
+        this.connectionState = ConnectionState.HANDSHAKING;
+
+        this.socket = null;
+
+        this.packetManager = new PacketManager({
+            registry: options.registry || defaultRegistry
+        });
+
+        this.uuid = null;
+        this.playerName = null;
+
+        this._setupPacketHandlers();
+    }
+
+    _setupPacketHandlers() {
+        
+        this.packetManager.on('packet', (event) => {
+            this.emit('packet', event);
+        });
+
+        this.packetManager.on('packetSend', (event) => {
+            this.emit('packetSend', event);
+        });
+
+        this.packetManager.on('unknownPacket', (data) => {
+            this.emit('unknownPacket', data);
+        });
+
+        this.packetManager.on('stateChange', (data) => {
+            this.connectionState = data.newState;
+            this.emit('stateChange', data);
+        });
+    }
+
+    connect() {
+        return new Promise((resolve, reject) => {
+            if (this.state !== ClientState.DISCONNECTED) {
+                reject(new Error('Client is already connected or connecting'));
+                return;
+            }
+
+            this.state = ClientState.CONNECTING;
+            logger.info(`Connecting to ${this.host}:${this.port}...`);
+
+            this.socket = createConnection({
+                host: this.host,
+                port: this.port
+            });
+
+            this.socket.on('connect', () => {
+                this.state = ClientState.CONNECTED;
+                logger.info('Connected!');
+                this.emit('connect');
+                resolve();
+            });
+
+            this.socket.on('data', async (data) => {
+                try {
+                    this.packetManager.addReceivedData(data);
+                    await this.packetManager.readPackets(
+                        PacketDirection.CLIENTBOUND,
+                        { connection: this }
+                    );
+                } catch (error) {
+                    logger.error('Error processing data:', error);
+                    this.emit('error', error);
+                }
+            });
+
+            this.socket.on('close', (hadError) => {
+                const wasConnected = this.state !== ClientState.DISCONNECTED;
+                this.state = ClientState.DISCONNECTED;
+                
+                if (wasConnected) {
+                    logger.info('Disconnected from server');
+                    this.emit('disconnect', { hadError });
+                }
+            });
+
+            this.socket.on('error', (error) => {
+                logger.error('Socket error:', error);
+                
+                if (this.state === ClientState.CONNECTING) {
+                    reject(error);
+                } else {
+                    this.emit('error', error);
+                }
+            });
+
+            this.socket.on('timeout', () => {
+                logger.warn('Connection timeout');
+                this.emit('timeout');
+            });
+        });
+    }
+
+    disconnect(reason) {
+        return new Promise((resolve) => {
+            if (this.state === ClientState.DISCONNECTED) {
+                resolve();
+                return;
+            }
+
+            this.state = ClientState.DISCONNECTING;
+            logger.info(`Disconnecting${reason ? `: ${reason}` : ''}...`);
+
+            if (this.socket) {
+                this.socket.end();
+                this.socket.destroy();
+                this.socket = null;
+            }
+
+            this.state = ClientState.DISCONNECTED;
+            this.packetManager.clearBuffer();
+            resolve();
+        });
+    }
+
+    async sendPacket(packet) {
+        if (!this.socket || this.state === ClientState.DISCONNECTED) {
+            throw new Error('Not connected to server');
+        }
+
+        return this.packetManager.sendPacket(
+            packet,
+            (data) => {
+                return new Promise((resolve, reject) => {
+                    this.socket.write(data, (err) => {
+                        if (err) reject(err);
+                        else resolve();
+                    });
+                });
+            },
+            { connection: this }
+        );
+    }
+
+    async ping() {
+        await this.connect();
+
+        try {
+            
+            const handshake = new HandshakePacket();
+            handshake.protocolVersion = this.version.protocolId;
+            handshake.serverAddress = this.host;
+            handshake.serverPort = this.port;
+            handshake.nextState = ConnectionState.STATUS.id;
+            
+            await this.sendPacket(handshake);
+            this.packetManager.setState(ConnectionState.STATUS);
+
+            await this.sendPacket(new StatusRequestPacket());
+
+            const response = await this.waitForPacket(StatusResponsePacket, 10000);
+
+            const pingPacket = new PingPacket();
+            pingPacket.payload = BigInt(Date.now());
+            await this.sendPacket(pingPacket);
+
+            const pong = await this.waitForPacket(PongPacket, 5000);
+            const latency = Date.now() - Number(pingPacket.payload);
+
+            await this.disconnect();
+
+            return {
+                ...response.status,
+                latency
+            };
+        } catch (error) {
+            await this.disconnect();
+            throw error;
+        }
+    }
+
+    async login() {
+        await this.connect();
+
+        try {
+            
+            const handshake = new HandshakePacket();
+            handshake.protocolVersion = this.version.protocolId;
+            handshake.serverAddress = this.host;
+            handshake.serverPort = this.port;
+            handshake.nextState = ConnectionState.LOGIN.id;
+            
+            await this.sendPacket(handshake);
+            this.packetManager.setState(ConnectionState.LOGIN);
+
+            const loginStart = new LoginStartPacket();
+            loginStart.username = this.username;
+            loginStart.uuid = this.offline ? 
+                UUID.offlinePlayerUUID(this.username) : 
+                UUID.randomUUID();
+            
+            await this.sendPacket(loginStart);
+            this.state = ClientState.AUTHENTICATING;
+
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new Error('Login timeout'));
+                }, 30000);
+
+                this.packetManager.onPacket(SetCompressionPacket, (event) => {
+                    const threshold = event.packet.threshold;
+                    this.packetManager.setCompression(threshold);
+                    logger.debug(`Compression set to ${threshold}`);
+                });
+
+                this.packetManager.onPacket(EncryptionRequestPacket, async (event) => {
+                    if (this.offline) {
+                        clearTimeout(timeout);
+                        reject(new Error('Server requires online mode authentication'));
+                        return;
+                    }
+
+                    logger.warn('Online mode encryption not fully implemented');
+                });
+
+                this.packetManager.onPacket(LoginSuccessPacket, (event) => {
+                    clearTimeout(timeout);
+                    
+                    this.uuid = event.packet.uuid;
+                    this.playerName = event.packet.username;
+                    this.state = ClientState.READY;
+
+                    this.packetManager.setState(ConnectionState.PLAY);
+                    
+                    this.emit('login', {
+                        uuid: this.uuid,
+                        username: this.playerName
+                    });
+
+                    resolve({
+                        uuid: this.uuid,
+                        username: this.playerName
+                    });
+                });
+
+                this.packetManager.onPacket(DisconnectPacket, (event) => {
+                    clearTimeout(timeout);
+                    const reason = event.packet.reason?.toPlainText?.() || 
+                                  JSON.stringify(event.packet.reason);
+                    reject(new Error(`Disconnected: ${reason}`));
+                });
+            });
+        } catch (error) {
+            await this.disconnect();
+            throw error;
+        }
+    }
+
+    waitForPacket(packetClass, timeout = 5000) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                this.packetManager.off(`packet:${packetClass.packetName}`, handler);
+                reject(new Error(`Timeout waiting for ${packetClass.packetName}`));
+            }, timeout);
+
+            const handler = (event) => {
+                clearTimeout(timeoutId);
+                resolve(event.packet);
+            };
+
+            this.packetManager.once(`packet:${packetClass.packetName}`, handler);
+        });
+    }
+
+    onPacket(packetClass, callback, options) {
+        this.packetManager.onPacket(packetClass, callback, options);
+        return this;
+    }
+
+    get isConnected() {
+        return this.state === ClientState.CONNECTED || 
+               this.state === ClientState.AUTHENTICATING || 
+               this.state === ClientState.READY;
+    }
+
+    get isReady() {
+        return this.state === ClientState.READY;
+    }
+
+    get protocolId() {
+        return this.version.protocolId;
+    }
+}
+
+export default MinecraftClient;

package/src/crypto/Encryption.js

@@ -0,0 +1,125 @@
+import * as crypto from 'crypto';
+
+export class MinecraftEncryption {
+    
+    static generateKeyPair() {
+        const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
+            modulusLength: 1024,
+            publicKeyEncoding: { type: 'spki', format: 'der' },
+            privateKeyEncoding: { type: 'pkcs8', format: 'der' }
+        });
+        return { publicKey, privateKey };
+    }
+
+    static generateVerifyToken() {
+        return crypto.randomBytes(4);
+    }
+
+    static generateSharedSecret() {
+        return crypto.randomBytes(16);
+    }
+
+    static generateServerId() {
+        return '';
+    }
+
+    static encryptRSA(publicKeyDER, data) {
+        const publicKey = crypto.createPublicKey({
+            key: publicKeyDER,
+            format: 'der',
+            type: 'spki'
+        });
+        
+        return crypto.publicEncrypt({
+            key: publicKey,
+            padding: crypto.constants.RSA_PKCS1_PADDING
+        }, data);
+    }
+
+    static decryptRSA(privateKeyDER, data) {
+        const privateKey = crypto.createPrivateKey({
+            key: privateKeyDER,
+            format: 'der',
+            type: 'pkcs8'
+        });
+        
+        return crypto.privateDecrypt({
+            key: privateKey,
+            padding: crypto.constants.RSA_PKCS1_PADDING
+        }, data);
+    }
+
+    static computeServerIdHash(serverId, sharedSecret, publicKeyDER) {
+        const hash = crypto.createHash('sha1');
+        hash.update(serverId, 'utf8');
+        hash.update(sharedSecret);
+        hash.update(publicKeyDER);
+        
+        return MinecraftEncryption.minecraftHexDigest(hash.digest());
+    }
+
+    static minecraftHexDigest(buffer) {
+        const isNegative = (buffer[0] & 0x80) !== 0;
+        
+        if (isNegative) {
+            let carry = true;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                buffer[i] = ~buffer[i] & 0xff;
+                if (carry) {
+                    carry = buffer[i] === 0xff;
+                    buffer[i] = (buffer[i] + 1) & 0xff;
+                }
+            }
+        }
+        
+        let hex = buffer.toString('hex').replace(/^0+/, '');
+        if (hex === '') hex = '0';
+        
+        return isNegative ? '-' + hex : hex;
+    }
+
+    static createCipherStream(sharedSecret) {
+        const cipher = crypto.createCipheriv('aes-128-cfb8', sharedSecret, sharedSecret);
+        return cipher;
+    }
+
+    static createDecipherStream(sharedSecret) {
+        const decipher = crypto.createDecipheriv('aes-128-cfb8', sharedSecret, sharedSecret);
+        return decipher;
+    }
+
+    static encryptAES(sharedSecret, data) {
+        const cipher = crypto.createCipheriv('aes-128-cfb8', sharedSecret, sharedSecret);
+        return Buffer.concat([cipher.update(data), cipher.final()]);
+    }
+
+    static decryptAES(sharedSecret, data) {
+        const decipher = crypto.createDecipheriv('aes-128-cfb8', sharedSecret, sharedSecret);
+        return Buffer.concat([decipher.update(data), decipher.final()]);
+    }
+}
+
+export class EncryptedConnection {
+    constructor(sharedSecret) {
+        this.sharedSecret = sharedSecret;
+        this.cipher = MinecraftEncryption.createCipherStream(sharedSecret);
+        this.decipher = MinecraftEncryption.createDecipherStream(sharedSecret);
+        this.enabled = false;
+    }
+
+    enable() {
+        this.enabled = true;
+    }
+
+    encrypt(data) {
+        if (!this.enabled) return data;
+        return this.cipher.update(data);
+    }
+
+    decrypt(data) {
+        if (!this.enabled) return data;
+        return this.decipher.update(data);
+    }
+}
+
+export default MinecraftEncryption;