packet-events-js 1.0.0 → 1.0.1

package/src/advanced/ProtocolAnalyzer.js

@@ -0,0 +1,396 @@
+import { EventEmitter } from '../events/EventEmitter.js';
+import { PacketBuffer } from '../utils/PacketBuffer.js';
+
+export class ProtocolMetrics {
+    constructor() {
+        this.reset();
+    }
+
+    reset() {
+        this.startTime = Date.now();
+        this.packetsReceived = 0;
+        this.packetsSent = 0;
+        this.bytesReceived = 0;
+        this.bytesSent = 0;
+        this.compressionSaved = 0;
+        this.encryptedPackets = 0;
+        this.errors = 0;
+        this.latencyHistory = [];
+        this.throughputHistory = [];
+        this.packetTypeStats = new Map();
+        this.stateTransitions = [];
+    }
+
+    recordPacket(direction, size, packetName, compressed = false, originalSize = 0) {
+        if (direction === 'CLIENTBOUND') {
+            this.packetsReceived++;
+            this.bytesReceived += size;
+        } else {
+            this.packetsSent++;
+            this.bytesSent += size;
+        }
+
+        if (compressed && originalSize > size) {
+            this.compressionSaved += (originalSize - size);
+        }
+
+        const stats = this.packetTypeStats.get(packetName) || { count: 0, bytes: 0 };
+        stats.count++;
+        stats.bytes += size;
+        this.packetTypeStats.set(packetName, stats);
+    }
+
+    recordLatency(ms) {
+        this.latencyHistory.push({ time: Date.now(), latency: ms });
+        if (this.latencyHistory.length > 1000) {
+            this.latencyHistory.shift();
+        }
+    }
+
+    recordStateTransition(from, to) {
+        this.stateTransitions.push({ time: Date.now(), from, to });
+    }
+
+    getAverageLatency() {
+        if (this.latencyHistory.length === 0) return 0;
+        return this.latencyHistory.reduce((a, b) => a + b.latency, 0) / this.latencyHistory.length;
+    }
+
+    getMinLatency() {
+        if (this.latencyHistory.length === 0) return 0;
+        return Math.min(...this.latencyHistory.map(l => l.latency));
+    }
+
+    getMaxLatency() {
+        if (this.latencyHistory.length === 0) return 0;
+        return Math.max(...this.latencyHistory.map(l => l.latency));
+    }
+
+    getThroughput() {
+        const elapsed = (Date.now() - this.startTime) / 1000;
+        return {
+            packetsPerSecond: ((this.packetsReceived + this.packetsSent) / elapsed).toFixed(2),
+            bytesPerSecond: ((this.bytesReceived + this.bytesSent) / elapsed).toFixed(2),
+            kbpsIn: ((this.bytesReceived / elapsed) / 1024 * 8).toFixed(2),
+            kbpsOut: ((this.bytesSent / elapsed) / 1024 * 8).toFixed(2)
+        };
+    }
+
+    getReport() {
+        const elapsed = (Date.now() - this.startTime) / 1000;
+        return {
+            duration: elapsed,
+            packets: {
+                received: this.packetsReceived,
+                sent: this.packetsSent,
+                total: this.packetsReceived + this.packetsSent
+            },
+            bytes: {
+                received: this.bytesReceived,
+                sent: this.bytesSent,
+                total: this.bytesReceived + this.bytesSent,
+                compressionSaved: this.compressionSaved
+            },
+            latency: {
+                average: this.getAverageLatency().toFixed(2),
+                min: this.getMinLatency(),
+                max: this.getMaxLatency(),
+                samples: this.latencyHistory.length
+            },
+            throughput: this.getThroughput(),
+            packetTypes: Object.fromEntries(this.packetTypeStats),
+            stateTransitions: this.stateTransitions,
+            errors: this.errors
+        };
+    }
+}
+
+export class PacketInspector {
+    constructor() {
+        this.inspectors = new Map();
+        this.registerDefaultInspectors();
+    }
+
+    registerDefaultInspectors() {
+        this.register('position', (packet) => {
+            const fields = ['x', 'y', 'z', 'yaw', 'pitch'];
+            const result = {};
+            for (const field of fields) {
+                if (packet[field] !== undefined) {
+                    result[field] = packet[field];
+                }
+            }
+            if (Object.keys(result).length > 0) {
+                result.blockPos = {
+                    x: Math.floor(result.x || 0),
+                    y: Math.floor(result.y || 0),
+                    z: Math.floor(result.z || 0)
+                };
+                result.chunkPos = {
+                    x: Math.floor((result.x || 0) / 16),
+                    z: Math.floor((result.z || 0) / 16)
+                };
+            }
+            return result;
+        });
+
+        this.register('entity', (packet) => {
+            const fields = ['entityId', 'entityUUID', 'entityType', 'velocityX', 'velocityY', 'velocityZ'];
+            const result = {};
+            for (const field of fields) {
+                if (packet[field] !== undefined) {
+                    result[field] = packet[field];
+                }
+            }
+            return result;
+        });
+
+        this.register('chat', (packet) => {
+            const result = {};
+            if (packet.message) result.message = packet.message;
+            if (packet.content) result.content = packet.content;
+            if (packet.sender) result.sender = packet.sender;
+            if (packet.type !== undefined) result.type = packet.type;
+            return result;
+        });
+    }
+
+    register(name, inspector) {
+        this.inspectors.set(name, inspector);
+        return this;
+    }
+
+    inspect(packet, inspectorName = null) {
+        const results = {};
+        
+        if (inspectorName) {
+            const inspector = this.inspectors.get(inspectorName);
+            if (inspector) {
+                results[inspectorName] = inspector(packet);
+            }
+        } else {
+            for (const [name, inspector] of this.inspectors) {
+                const result = inspector(packet);
+                if (Object.keys(result).length > 0) {
+                    results[name] = result;
+                }
+            }
+        }
+
+        return results;
+    }
+
+    hexDump(buffer, bytesPerLine = 16) {
+        const lines = [];
+        for (let i = 0; i < buffer.length; i += bytesPerLine) {
+            const slice = buffer.subarray(i, Math.min(i + bytesPerLine, buffer.length));
+            const hex = [...slice].map(b => b.toString(16).padStart(2, '0')).join(' ');
+            const ascii = [...slice].map(b => b >= 32 && b <= 126 ? String.fromCharCode(b) : '.').join('');
+            lines.push(`${i.toString(16).padStart(8, '0')}  ${hex.padEnd(bytesPerLine * 3 - 1)}  |${ascii}|`);
+        }
+        return lines.join('\n');
+    }
+
+    analyzeStructure(packet) {
+        const structure = {
+            className: packet.constructor.name,
+            packetId: packet.constructor.packetId,
+            packetName: packet.constructor.packetName,
+            fields: []
+        };
+
+        for (const [key, value] of Object.entries(packet)) {
+            if (key.startsWith('_')) continue;
+            
+            let type = typeof value;
+            let details = {};
+
+            if (value === null) {
+                type = 'null';
+            } else if (value === undefined) {
+                type = 'undefined';
+            } else if (Buffer.isBuffer(value)) {
+                type = 'Buffer';
+                details.length = value.length;
+            } else if (Array.isArray(value)) {
+                type = 'Array';
+                details.length = value.length;
+            } else if (typeof value === 'bigint') {
+                type = 'BigInt';
+                details.value = value.toString();
+            } else if (value && typeof value === 'object') {
+                type = value.constructor.name;
+                if (value.toString) {
+                    details.string = value.toString();
+                }
+            }
+
+            structure.fields.push({ name: key, type, value: details.value || value, details });
+        }
+
+        return structure;
+    }
+}
+
+export class ProtocolAnalyzer extends EventEmitter {
+    constructor(options = {}) {
+        super();
+        
+        this.metrics = new ProtocolMetrics();
+        this.inspector = new PacketInspector();
+        this.isAnalyzing = false;
+        this.filters = options.filters || [];
+        this.alerts = [];
+        this.alertRules = new Map();
+        
+        this.setupDefaultAlerts();
+    }
+
+    setupDefaultAlerts() {
+        this.addAlertRule('high_latency', (metrics) => {
+            if (metrics.getAverageLatency() > 200) {
+                return { level: 'warning', message: `High latency: ${metrics.getAverageLatency().toFixed(0)}ms` };
+            }
+            return null;
+        });
+
+        this.addAlertRule('packet_flood', (metrics) => {
+            const throughput = metrics.getThroughput();
+            if (parseFloat(throughput.packetsPerSecond) > 1000) {
+                return { level: 'warning', message: `High packet rate: ${throughput.packetsPerSecond}/s` };
+            }
+            return null;
+        });
+
+        this.addAlertRule('error_rate', (metrics) => {
+            const total = metrics.packetsReceived + metrics.packetsSent;
+            if (total > 100 && (metrics.errors / total) > 0.01) {
+                return { level: 'error', message: `High error rate: ${(metrics.errors / total * 100).toFixed(2)}%` };
+            }
+            return null;
+        });
+    }
+
+    addAlertRule(name, rule) {
+        this.alertRules.set(name, rule);
+        return this;
+    }
+
+    removeAlertRule(name) {
+        this.alertRules.delete(name);
+        return this;
+    }
+
+    checkAlerts() {
+        for (const [name, rule] of this.alertRules) {
+            const alert = rule(this.metrics);
+            if (alert) {
+                const alertRecord = {
+                    time: Date.now(),
+                    rule: name,
+                    ...alert
+                };
+                this.alerts.push(alertRecord);
+                this.emit('alert', alertRecord);
+            }
+        }
+    }
+
+    start() {
+        this.isAnalyzing = true;
+        this.metrics.reset();
+        this.alerts = [];
+        this.emit('start');
+        return this;
+    }
+
+    stop() {
+        this.isAnalyzing = false;
+        this.emit('stop', this.getReport());
+        return this;
+    }
+
+    analyzePacket(packet, direction, state, rawData) {
+        if (!this.isAnalyzing) return null;
+
+        const analysis = {
+            timestamp: Date.now(),
+            direction,
+            state: typeof state === 'object' ? state.name : state,
+            packetName: packet.constructor.packetName,
+            packetId: packet.constructor.packetId,
+            size: rawData.length,
+            inspection: this.inspector.inspect(packet),
+            structure: this.inspector.analyzeStructure(packet)
+        };
+
+        this.metrics.recordPacket(direction, rawData.length, packet.constructor.packetName);
+        
+        if ((this.metrics.packetsReceived + this.metrics.packetsSent) % 100 === 0) {
+            this.checkAlerts();
+        }
+
+        this.emit('packet', analysis);
+        return analysis;
+    }
+
+    recordLatency(ms) {
+        this.metrics.recordLatency(ms);
+        this.emit('latency', ms);
+    }
+
+    recordError(error) {
+        this.metrics.errors++;
+        this.emit('error', error);
+    }
+
+    recordStateTransition(from, to) {
+        this.metrics.recordStateTransition(from, to);
+        this.emit('stateChange', { from, to });
+    }
+
+    getReport() {
+        return {
+            ...this.metrics.getReport(),
+            alerts: this.alerts,
+            isAnalyzing: this.isAnalyzing
+        };
+    }
+
+    getTopPackets(limit = 10) {
+        const sorted = [...this.metrics.packetTypeStats.entries()]
+            .sort((a, b) => b[1].count - a[1].count)
+            .slice(0, limit);
+        
+        return sorted.map(([name, stats]) => ({
+            name,
+            count: stats.count,
+            bytes: stats.bytes,
+            avgSize: (stats.bytes / stats.count).toFixed(1)
+        }));
+    }
+
+    generateTrafficGraph(width = 60) {
+        const history = this.metrics.latencyHistory.slice(-width);
+        if (history.length === 0) return 'No data';
+
+        const max = Math.max(...history.map(h => h.latency), 1);
+        const height = 10;
+        const lines = [];
+
+        for (let y = height; y >= 0; y--) {
+            let line = `${Math.round(max * y / height).toString().padStart(4)} |`;
+            for (const h of history) {
+                const barHeight = Math.round((h.latency / max) * height);
+                line += barHeight >= y ? '█' : ' ';
+            }
+            lines.push(line);
+        }
+        lines.push('     +' + '-'.repeat(width));
+        lines.push('      Latency over time (ms)');
+
+        return lines.join('\n');
+    }
+}
+
+export default { ProtocolAnalyzer, ProtocolMetrics, PacketInspector };

package/src/advanced/index.js

@@ -0,0 +1,32 @@
+export { 
+    PacketRecorder, 
+    PacketReplayer, 
+    PacketRecord 
+} from './PacketRecorder.js';
+
+export { 
+    ProtocolAnalyzer, 
+    ProtocolMetrics, 
+    PacketInspector 
+} from './ProtocolAnalyzer.js';
+
+export {
+    MiddlewarePipeline,
+    MiddlewareContext,
+    Middleware,
+    LoggingMiddleware,
+    RateLimitMiddleware,
+    ValidationMiddleware,
+    TransformMiddleware,
+    CacheMiddleware,
+    MetricsMiddleware
+} from './MiddlewareSystem.js';
+
+export {
+    AutoReconnect,
+    ReconnectStrategy,
+    HealthMonitor,
+    HealthStatus,
+    ConnectionPool,
+    CircuitBreaker
+} from './ConnectionManager.js';

package/src/auth/AuthHandler.js

@@ -1,6 +1,7 @@
 import { MinecraftEncryption, EncryptedConnection } from '../crypto/Encryption.js';
 import { MojangAPI } from './MojangAPI.js';
 import { UUID } from '../protocol/types/UUID.js';
+import { createHmac } from 'crypto';
 
 export const AuthMode = Object.freeze({
     ONLINE: 'online',
@@ -9,11 +10,228 @@ export const AuthMode = Object.freeze({
     VELOCITY: 'velocity'
 });
 
+export class BungeeCordForwarding {
+    static parse(serverAddress) {
+        const parts = serverAddress.split('\0');
+        
+        if (parts.length < 3) {
+            return { success: false, reason: 'INVALID_FORMAT' };
+        }
+
+        const hostname = parts[0];
+        const clientIP = parts[1];
+        const uuidString = parts[2];
+        
+        let properties = [];
+        if (parts.length > 3 && parts[3]) {
+            try {
+                properties = JSON.parse(parts[3]);
+            } catch (e) {
+                properties = [];
+            }
+        }
+
+        let uuid;
+        try {
+            uuid = UUID.fromString(uuidString);
+        } catch (e) {
+            return { success: false, reason: 'INVALID_UUID' };
+        }
+
+        return {
+            success: true,
+            hostname,
+            clientIP,
+            uuid,
+            properties
+        };
+    }
+
+    static create(hostname, clientIP, uuid, properties = []) {
+        const uuidString = uuid.toString(false);
+        const propsJson = properties.length > 0 ? JSON.stringify(properties) : '';
+        
+        if (propsJson) {
+            return `${hostname}\0${clientIP}\0${uuidString}\0${propsJson}`;
+        }
+        return `${hostname}\0${clientIP}\0${uuidString}`;
+    }
+}
+
+export class VelocityForwarding {
+    static MODERN_FORWARDING_VERSION = 1;
+    static MODERN_LAZY_SESSION = 2;
+    static MODERN_FORWARDING_WITH_KEY = 3;
+    static MODERN_FORWARDING_WITH_KEY_V2 = 4;
+
+    static verify(data, secret) {
+        if (!secret) {
+            return { success: false, reason: 'NO_SECRET' };
+        }
+
+        if (data.length < 32) {
+            return { success: false, reason: 'DATA_TOO_SHORT' };
+        }
+
+        const signature = data.subarray(0, 32);
+        const payload = data.subarray(32);
+
+        const expectedSignature = createHmac('sha256', secret)
+            .update(payload)
+            .digest();
+
+        if (!signature.equals(expectedSignature)) {
+            return { success: false, reason: 'INVALID_SIGNATURE' };
+        }
+
+        return VelocityForwarding.parsePayload(payload);
+    }
+
+    static parsePayload(payload) {
+        try {
+            let offset = 0;
+
+            const version = payload.readInt32BE(offset);
+            offset += 4;
+
+            const ipLength = payload.readInt16BE(offset);
+            offset += 2;
+            const clientIP = payload.subarray(offset, offset + ipLength).toString('utf8');
+            offset += ipLength;
+
+            const uuidBytes = payload.subarray(offset, offset + 16);
+            offset += 16;
+            const uuid = UUID.fromBytes(uuidBytes);
+
+            const usernameLength = payload.readInt16BE(offset);
+            offset += 2;
+            const username = payload.subarray(offset, offset + usernameLength).toString('utf8');
+            offset += usernameLength;
+
+            let properties = [];
+            if (offset < payload.length) {
+                const propsCount = payload.readInt32BE(offset);
+                offset += 4;
+
+                for (let i = 0; i < propsCount; i++) {
+                    const nameLen = payload.readInt16BE(offset);
+                    offset += 2;
+                    const name = payload.subarray(offset, offset + nameLen).toString('utf8');
+                    offset += nameLen;
+
+                    const valueLen = payload.readInt16BE(offset);
+                    offset += 2;
+                    const value = payload.subarray(offset, offset + valueLen).toString('utf8');
+                    offset += valueLen;
+
+                    const hasSignature = payload.readInt8(offset) === 1;
+                    offset += 1;
+
+                    let signature = null;
+                    if (hasSignature) {
+                        const sigLen = payload.readInt16BE(offset);
+                        offset += 2;
+                        signature = payload.subarray(offset, offset + sigLen).toString('utf8');
+                        offset += sigLen;
+                    }
+
+                    properties.push({ name, value, signature });
+                }
+            }
+
+            return {
+                success: true,
+                version,
+                clientIP,
+                uuid,
+                username,
+                properties
+            };
+        } catch (e) {
+            return { success: false, reason: 'PARSE_ERROR', error: e.message };
+        }
+    }
+
+    static create(secret, clientIP, uuid, username, properties = [], version = 1) {
+        const ipBuffer = Buffer.from(clientIP, 'utf8');
+        const usernameBuffer = Buffer.from(username, 'utf8');
+        const uuidBytes = uuid.toBytes();
+
+        let propsSize = 4;
+        const propBuffers = [];
+        for (const prop of properties) {
+            const nameBuffer = Buffer.from(prop.name, 'utf8');
+            const valueBuffer = Buffer.from(prop.value, 'utf8');
+            propBuffers.push({ name: nameBuffer, value: valueBuffer, signature: prop.signature });
+            propsSize += 2 + nameBuffer.length + 2 + valueBuffer.length + 1;
+            if (prop.signature) {
+                const sigBuffer = Buffer.from(prop.signature, 'utf8');
+                propBuffers[propBuffers.length - 1].sigBuffer = sigBuffer;
+                propsSize += 2 + sigBuffer.length;
+            }
+        }
+
+        const payloadSize = 4 + 2 + ipBuffer.length + 16 + 2 + usernameBuffer.length + propsSize;
+        const payload = Buffer.alloc(payloadSize);
+        let offset = 0;
+
+        payload.writeInt32BE(version, offset);
+        offset += 4;
+
+        payload.writeInt16BE(ipBuffer.length, offset);
+        offset += 2;
+        ipBuffer.copy(payload, offset);
+        offset += ipBuffer.length;
+
+        uuidBytes.copy(payload, offset);
+        offset += 16;
+
+        payload.writeInt16BE(usernameBuffer.length, offset);
+        offset += 2;
+        usernameBuffer.copy(payload, offset);
+        offset += usernameBuffer.length;
+
+        payload.writeInt32BE(properties.length, offset);
+        offset += 4;
+
+        for (const prop of propBuffers) {
+            payload.writeInt16BE(prop.name.length, offset);
+            offset += 2;
+            prop.name.copy(payload, offset);
+            offset += prop.name.length;
+
+            payload.writeInt16BE(prop.value.length, offset);
+            offset += 2;
+            prop.value.copy(payload, offset);
+            offset += prop.value.length;
+
+            if (prop.signature && prop.sigBuffer) {
+                payload.writeInt8(1, offset);
+                offset += 1;
+                payload.writeInt16BE(prop.sigBuffer.length, offset);
+                offset += 2;
+                prop.sigBuffer.copy(payload, offset);
+                offset += prop.sigBuffer.length;
+            } else {
+                payload.writeInt8(0, offset);
+                offset += 1;
+            }
+        }
+
+        const signature = createHmac('sha256', secret)
+            .update(payload)
+            .digest();
+
+        return Buffer.concat([signature, payload]);
+    }
+}
+
 export class AuthHandler {
     constructor(options = {}) {
         this.mode = options.mode || AuthMode.OFFLINE;
         this.preventProxyConnections = options.preventProxyConnections || false;
         this.velocitySecret = options.velocitySecret || null;
+        this.bungeeCordEnabled = options.bungeeCordEnabled || (this.mode === AuthMode.BUNGEECORD);
         this.keyPair = null;
     }
 
@@ -23,6 +241,34 @@ export class AuthHandler {
         }
     }
 
+    handleBungeeCordForwarding(serverAddress) {
+        if (this.mode !== AuthMode.BUNGEECORD) {
+            return { success: false, reason: 'BUNGEECORD_NOT_ENABLED' };
+        }
+        return BungeeCordForwarding.parse(serverAddress);
+    }
+
+    handleVelocityForwarding(data) {
+        if (this.mode !== AuthMode.VELOCITY) {
+            return { success: false, reason: 'VELOCITY_NOT_ENABLED' };
+        }
+        if (!this.velocitySecret) {
+            return { success: false, reason: 'NO_VELOCITY_SECRET' };
+        }
+        return VelocityForwarding.verify(data, this.velocitySecret);
+    }
+
+    createBungeeCordHandshake(hostname, clientIP, uuid, properties = []) {
+        return BungeeCordForwarding.create(hostname, clientIP, uuid, properties);
+    }
+
+    createVelocityForwarding(clientIP, uuid, username, properties = []) {
+        if (!this.velocitySecret) {
+            throw new Error('Velocity secret not configured');
+        }
+        return VelocityForwarding.create(this.velocitySecret, clientIP, uuid, username, properties);
+    }
+
     getPublicKey() {
         if (!this.keyPair) return null;
         return this.keyPair.publicKey;

package/src/index.js

@@ -15,4 +15,6 @@ export { Logger, LogLevel } from './utils/Logger.js';
 
 export { MinecraftEncryption, EncryptedConnection } from './crypto/Encryption.js';
 export { MojangAPI } from './auth/MojangAPI.js';
-export { AuthHandler, ClientAuthHandler, AuthMode } from './auth/AuthHandler.js';
+export { AuthHandler, ClientAuthHandler, AuthMode, BungeeCordForwarding, VelocityForwarding } from './auth/AuthHandler.js';
+
+export * from './advanced/index.js';