packet-events-js 1.0.0

package/README.md

@@ -0,0 +1,398 @@
+# PacketEvents-JS
+
+A robust protocol library for **Minecraft Java Edition** written entirely in **pure JavaScript**. Inspired by [PacketEvents](https://github.com/retrooper/packetevents), designed to facilitate the processing and transmission of Minecraft protocol packets with full online mode support.
+
+## Features
+
+- **Pure JavaScript** - No external dependencies, only native Node.js
+- **TCP Connection** - Complete TCP client for Minecraft
+- **Packet System** - Read/write all protocol data types
+- **Event System** - Priority-based events with cancellation and async/await
+- **Compression** - Full zlib compression support
+- **Encryption** - Complete AES-128-CFB8 encryption support for online mode
+- **Online Mode** - Full Mojang/Microsoft authentication support
+- **Offline Mode** - Offline player UUID generation (version 3)
+- **Complete NBT** - Named Binary Tag read/write
+- **Chat Components** - JSON Text Component with colors, formatting, and events
+- **Multi-version** - Support for Minecraft 1.7.2 to 1.21.11 (66 versions)
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- ES Modules enabled
+
+## Installation
+
+```bash
+npm install packet-events-js
+```
+
+Or clone the repository:
+
+```bash
+git clone https://github.com/FrannnnDev/PacketEvents-JS.git
+cd PacketEvents-JS
+```
+
+## Basic Usage
+
+### Server List Ping
+
+```javascript
+import { MinecraftClient, ProtocolVersion } from 'packet-events-js';
+
+const client = new MinecraftClient({
+    host: 'mc.hypixel.net',
+    port: 25565,
+    version: ProtocolVersion.V1_21_11
+});
+
+const status = await client.ping();
+console.log(`Players: ${status.players.online}/${status.players.max}`);
+console.log(`Latency: ${status.latency}ms`);
+```
+
+### Connect to Server (Offline Mode)
+
+```javascript
+import { MinecraftClient, ProtocolVersion, Logger, LogLevel } from 'packet-events-js';
+import { KeepAliveClientboundPacket, KeepAliveServerboundPacket } from 'packet-events-js/protocol/packets';
+
+Logger.setGlobalLevel(LogLevel.DEBUG);
+
+const client = new MinecraftClient({
+    host: 'localhost',
+    port: 25565,
+    version: ProtocolVersion.V1_21_11,
+    username: 'MyBot',
+    offline: true
+});
+
+client.onPacket(KeepAliveClientboundPacket, async (event) => {
+    const response = new KeepAliveServerboundPacket();
+    response.keepAliveId = event.packet.keepAliveId;
+    await client.sendPacket(response);
+});
+
+await client.login();
+console.log(`Connected as ${client.playerName}`);
+```
+
+### Encryption API
+
+```javascript
+import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js/crypto/Encryption';
+
+const keyPair = MinecraftEncryption.generateKeyPair();
+console.log('Public Key:', keyPair.publicKey);
+console.log('Private Key:', keyPair.privateKey);
+
+const verifyToken = MinecraftEncryption.generateVerifyToken();
+const sharedSecret = MinecraftEncryption.generateSharedSecret();
+
+const encrypted = MinecraftEncryption.encryptRSA(keyPair.publicKey, sharedSecret);
+const decrypted = MinecraftEncryption.decryptRSA(keyPair.privateKey, encrypted);
+
+const aesEncrypted = MinecraftEncryption.encryptAES(sharedSecret, Buffer.from('Hello'));
+const aesDecrypted = MinecraftEncryption.decryptAES(sharedSecret, aesEncrypted);
+
+const serverHash = MinecraftEncryption.computeServerIdHash('', sharedSecret, keyPair.publicKey);
+```
+
+### Auth Handler
+
+```javascript
+import { AuthHandler, ClientAuthHandler, AuthMode } from 'packet-events-js/auth/AuthHandler';
+
+const serverAuth = new AuthHandler({ mode: AuthMode.ONLINE });
+serverAuth.initialize();
+
+const publicKey = serverAuth.getPublicKey();
+const verifyToken = serverAuth.generateVerifyToken();
+
+const offlineUUID = serverAuth.generateOfflineUUID('PlayerName');
+
+const clientAuth = new ClientAuthHandler({
+    accessToken: 'token',
+    selectedProfile: { id: 'uuid', name: 'Name' }
+});
+```
+
+### Intercept Packets
+
+```javascript
+import { EventPriority } from 'packet-events-js/events/EventEmitter';
+
+client.packetManager.on('packetSend', (event) => {
+    if (event.packet.packetName === 'SetPlayerPosition') {
+        console.log(`Moving to: ${event.packet.x}, ${event.packet.y}, ${event.packet.z}`);
+        
+        if (event.packet.y < 0) {
+            event.cancel();
+        }
+    }
+}, { priority: EventPriority.HIGH });
+```
+
+### Create Custom Packets
+
+```javascript
+import { Packet } from 'packet-events-js/protocol/packets/Packet';
+import { defaultRegistry } from 'packet-events-js/protocol/packets/PacketRegistry';
+import { ConnectionState } from 'packet-events-js/protocol/ConnectionState';
+import { PacketDirection } from 'packet-events-js/protocol/PacketDirection';
+
+class MyCustomPacket extends Packet {
+    static get packetId() { return 0x50; }
+    static get packetName() { return 'MyPacket'; }
+
+    constructor() {
+        super();
+        this.myField = 0;
+    }
+
+    read(buffer, context) {
+        this.myField = buffer.readVarInt();
+    }
+
+    write(buffer, context) {
+        buffer.writeVarInt(this.myField);
+    }
+}
+
+defaultRegistry.register({
+    packetClass: MyCustomPacket,
+    state: ConnectionState.PLAY,
+    direction: PacketDirection.CLIENTBOUND,
+    packetId: 0x50
+});
+```
+
+## Project Structure
+
+```
+PacketEvents-JS/
+├── src/
+│   ├── index.js
+│   ├── auth/
+│   │   ├── AuthHandler.js
+│   │   └── MojangAPI.js
+│   ├── client/
+│   │   └── MinecraftClient.js
+│   ├── crypto/
+│   │   └── Encryption.js
+│   ├── events/
+│   │   ├── EventEmitter.js
+│   │   └── PacketEvent.js
+│   ├── manager/
+│   │   └── PacketManager.js
+│   ├── protocol/
+│   │   ├── ConnectionState.js
+│   │   ├── PacketDirection.js
+│   │   ├── ProtocolVersion.js
+│   │   ├── types/
+│   │   │   ├── VarInt.js
+│   │   │   ├── UUID.js
+│   │   │   ├── Position.js
+│   │   │   ├── NBT.js
+│   │   │   └── TextComponent.js
+│   │   └── packets/
+│   │       ├── Packet.js
+│   │       ├── PacketRegistry.js
+│   │       ├── handshake/
+│   │       ├── status/
+│   │       ├── login/
+│   │       └── play/
+│   └── utils/
+│       ├── PacketBuffer.js
+│       └── Logger.js
+└── examples/
+```
+
+## Main API
+
+### MinecraftClient
+
+```javascript
+const client = new MinecraftClient({
+    host: string,
+    port: number,
+    version: ProtocolVersion,
+    username: string,
+    offline: boolean,
+    accessToken: string,
+    selectedProfile: object,
+    registry: PacketRegistry
+});
+
+await client.connect();
+await client.ping();
+await client.login();
+await client.sendPacket(packet);
+await client.disconnect();
+
+client.isConnected;
+client.isReady;
+client.uuid;
+client.playerName;
+```
+
+### PacketBuffer
+
+```javascript
+import { PacketBuffer } from 'packet-events-js/utils/PacketBuffer';
+
+const buffer = PacketBuffer.writer();
+
+buffer.writeBoolean(true);
+buffer.writeByte(42);
+buffer.writeShort(1000);
+buffer.writeInt(100000);
+buffer.writeLong(9999999999n);
+buffer.writeFloat(3.14);
+buffer.writeDouble(3.14159265);
+buffer.writeVarInt(12345);
+buffer.writeString("Hello Minecraft");
+buffer.writeUUID(uuid);
+buffer.writePosition(position);
+buffer.writeNBT(nbtCompound);
+
+const data = buffer.getBuffer();
+
+const reader = PacketBuffer.reader(data);
+const bool = reader.readBoolean();
+const num = reader.readVarInt();
+const str = reader.readString();
+```
+
+### MinecraftEncryption
+
+```javascript
+import { MinecraftEncryption, EncryptedConnection } from 'packet-events-js/crypto/Encryption';
+
+const keyPair = MinecraftEncryption.generateKeyPair();
+
+const verifyToken = MinecraftEncryption.generateVerifyToken();
+const sharedSecret = MinecraftEncryption.generateSharedSecret();
+
+MinecraftEncryption.encryptRSA(publicKey, data);
+MinecraftEncryption.decryptRSA(privateKey, data);
+
+MinecraftEncryption.encryptAES(secret, data);
+MinecraftEncryption.decryptAES(secret, data);
+
+MinecraftEncryption.computeServerIdHash(serverId, sharedSecret, publicKey);
+
+const conn = new EncryptedConnection(sharedSecret);
+conn.enable();
+const encrypted = conn.encrypt(data);
+const decrypted = conn.decrypt(data);
+```
+
+### AuthHandler
+
+```javascript
+import { AuthHandler, ClientAuthHandler, AuthMode } from 'packet-events-js/auth/AuthHandler';
+
+AuthMode.ONLINE;
+AuthMode.OFFLINE;
+AuthMode.BUNGEECORD;
+AuthMode.VELOCITY;
+
+const handler = new AuthHandler({ mode: AuthMode.ONLINE });
+handler.initialize();
+handler.getPublicKey();
+handler.generateVerifyToken();
+handler.generateOfflineUUID(username);
+```
+
+### EventEmitter
+
+```javascript
+import { EventPriority } from 'packet-events-js/events/EventEmitter';
+
+EventPriority.LOWEST;
+EventPriority.LOW;
+EventPriority.NORMAL;
+EventPriority.HIGH;
+EventPriority.HIGHEST;
+EventPriority.MONITOR;
+
+emitter.on('event', callback, { priority: EventPriority.HIGH });
+
+emitter.on('packet', (event) => {
+    event.cancel();
+});
+
+await emitter.emitAsync('event', data);
+```
+
+### TextComponent
+
+```javascript
+import { TextComponent, ChatColor } from 'packet-events-js/protocol/types/TextComponent';
+
+const message = TextComponent.text('Hello!')
+    .color(ChatColor.GREEN)
+    .bold()
+    .append(
+        TextComponent.text(' World')
+            .color(ChatColor.YELLOW)
+            .italic()
+    )
+    .clickEvent('run_command', '/help')
+    .showText(TextComponent.text('Click for help'));
+
+const json = message.toString();
+```
+
+## Supported Versions
+
+66 versions supported from **1.7.2** to **1.21.11**:
+
+| Range | Versions |
+|-------|----------|
+| 1.21.x | 1.21.11, 1.21.10, 1.21.9, 1.21.8, 1.21.7, 1.21.6, 1.21.5, 1.21.4, 1.21.3, 1.21.2, 1.21.1, 1.21 |
+| 1.20.x | 1.20.6, 1.20.5, 1.20.4, 1.20.3, 1.20.2, 1.20.1, 1.20 |
+| 1.19.x | 1.19.4, 1.19.3, 1.19.2, 1.19.1, 1.19 |
+| 1.18.x | 1.18.2, 1.18.1, 1.18 |
+| 1.17.x | 1.17.1, 1.17 |
+| 1.16.x | 1.16.5, 1.16.4, 1.16.3, 1.16.2, 1.16.1, 1.16 |
+| 1.15.x | 1.15.2, 1.15.1, 1.15 |
+| 1.14.x | 1.14.4, 1.14.3, 1.14.2, 1.14.1, 1.14 |
+| 1.13.x | 1.13.2, 1.13.1, 1.13 |
+| 1.12.x | 1.12.2, 1.12.1, 1.12 |
+| 1.11.x | 1.11.2, 1.11.1, 1.11 |
+| 1.10.x | 1.10.2, 1.10.1, 1.10 |
+| 1.9.x | 1.9.4, 1.9.3, 1.9.2, 1.9.1, 1.9 |
+| 1.8.x | 1.8.9, 1.8.8, 1.8.7, 1.8.6, 1.8.5, 1.8.4, 1.8.3, 1.8.2, 1.8.1, 1.8 |
+| 1.7.x | 1.7.10, 1.7.9, 1.7.6, 1.7.5, 1.7.4, 1.7.2 |
+
+## Examples
+
+See the [examples](./examples) folder for complete usage examples:
+
+- `basic-client.js` - Basic client connection
+- `server-ping.js` - Server list ping
+- `packet-types.js` - All packet types demonstration
+- `encryption.js` - Encryption usage
+- `authentication.js` - Authentication modes
+- `event-system.js` - Event system usage
+- `packet-buffer.js` - PacketBuffer operations
+- `data-types.js` - Protocol data types
+- `protocol-versions.js` - Protocol version utilities
+- `connection-flows.js` - Connection flow examples
+- `custom-packets.js` - Custom packet creation
+- `packet-interception.js` - Packet interception
+
+## References
+
+This project is inspired by:
+
+- [PacketEvents](https://github.com/retrooper/packetevents) - Original Java library
+- [wiki.vg Protocol](https://wiki.vg/Protocol) - Protocol documentation
+- [MCProtocolLib](https://github.com/GeyserMC/MCProtocolLib) - Reference implementation
+
+## License
+
+MIT License

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "packet-events-js",
+  "version": "1.0.0",
+  "description": "A protocol library for Minecraft Java Edition in pure JavaScript",
+  "main": "src/index.js",
+  "type": "module",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "example": "node examples/basic-client.js",
+    "test": "node examples/packet-types.js && node examples/data-types.js && node examples/encryption.js"
+  },
+  "keywords": [
+    "minecraft",
+    "protocol",
+    "packets",
+    "java-edition",
+    "networking"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/FrannnnDev/PacketEvents-JS.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/auth/AuthHandler.js

@@ -0,0 +1,138 @@
+import { MinecraftEncryption, EncryptedConnection } from '../crypto/Encryption.js';
+import { MojangAPI } from './MojangAPI.js';
+import { UUID } from '../protocol/types/UUID.js';
+
+export const AuthMode = Object.freeze({
+    ONLINE: 'online',
+    OFFLINE: 'offline',
+    BUNGEECORD: 'bungeecord',
+    VELOCITY: 'velocity'
+});
+
+export class AuthHandler {
+    constructor(options = {}) {
+        this.mode = options.mode || AuthMode.OFFLINE;
+        this.preventProxyConnections = options.preventProxyConnections || false;
+        this.velocitySecret = options.velocitySecret || null;
+        this.keyPair = null;
+    }
+
+    initialize() {
+        if (this.mode === AuthMode.ONLINE) {
+            this.keyPair = MinecraftEncryption.generateKeyPair();
+        }
+    }
+
+    getPublicKey() {
+        if (!this.keyPair) return null;
+        return this.keyPair.publicKey;
+    }
+
+    generateVerifyToken() {
+        return MinecraftEncryption.generateVerifyToken();
+    }
+
+    decryptVerifyToken(encryptedToken) {
+        if (!this.keyPair) throw new Error('No key pair available');
+        return MinecraftEncryption.decryptRSA(this.keyPair.privateKey, encryptedToken);
+    }
+
+    decryptSharedSecret(encryptedSecret) {
+        if (!this.keyPair) throw new Error('No key pair available');
+        return MinecraftEncryption.decryptRSA(this.keyPair.privateKey, encryptedSecret);
+    }
+
+    computeServerHash(sharedSecret) {
+        if (!this.keyPair) throw new Error('No key pair available');
+        return MinecraftEncryption.computeServerIdHash('', sharedSecret, this.keyPair.publicKey);
+    }
+
+    createEncryptedConnection(sharedSecret) {
+        return new EncryptedConnection(sharedSecret);
+    }
+
+    async verifyPlayer(username, serverHash, clientIP = null) {
+        if (this.mode !== AuthMode.ONLINE) {
+            return {
+                success: true,
+                uuid: UUID.offlinePlayerUUID(username).toString(false),
+                name: username,
+                properties: []
+            };
+        }
+
+        const ip = this.preventProxyConnections ? clientIP : null;
+        return await MojangAPI.hasJoinedServer(username, serverHash, ip);
+    }
+
+    generateOfflineUUID(username) {
+        return UUID.offlinePlayerUUID(username);
+    }
+
+    async authenticate(username, encryptedSharedSecret, encryptedVerifyToken, originalVerifyToken, clientIP = null) {
+        const verifyToken = this.decryptVerifyToken(encryptedVerifyToken);
+        
+        if (!verifyToken.equals(originalVerifyToken)) {
+            return { success: false, reason: 'INVALID_VERIFY_TOKEN' };
+        }
+
+        const sharedSecret = this.decryptSharedSecret(encryptedSharedSecret);
+        
+        if (sharedSecret.length !== 16) {
+            return { success: false, reason: 'INVALID_SHARED_SECRET' };
+        }
+
+        const serverHash = this.computeServerHash(sharedSecret);
+        const verification = await this.verifyPlayer(username, serverHash, clientIP);
+
+        if (!verification.success) {
+            return { success: false, reason: verification.reason || 'AUTHENTICATION_FAILED' };
+        }
+
+        const encryptedConnection = this.createEncryptedConnection(sharedSecret);
+
+        return {
+            success: true,
+            uuid: verification.uuid,
+            name: verification.name,
+            properties: verification.properties || [],
+            encryption: encryptedConnection,
+            sharedSecret
+        };
+    }
+}
+
+export class ClientAuthHandler {
+    constructor(options = {}) {
+        this.accessToken = options.accessToken || null;
+        this.profileId = options.profileId || null;
+    }
+
+    async authenticateWithServer(serverPublicKey, verifyToken, serverId = '') {
+        const sharedSecret = MinecraftEncryption.generateSharedSecret();
+        
+        const encryptedSharedSecret = MinecraftEncryption.encryptRSA(serverPublicKey, sharedSecret);
+        const encryptedVerifyToken = MinecraftEncryption.encryptRSA(serverPublicKey, verifyToken);
+        
+        const serverHash = MinecraftEncryption.computeServerIdHash(serverId, sharedSecret, serverPublicKey);
+
+        if (this.accessToken && this.profileId) {
+            const result = await MojangAPI.joinServer(this.accessToken, this.profileId, serverHash);
+            if (!result.success) {
+                return { success: false, reason: result.error || 'JOIN_FAILED' };
+            }
+        }
+
+        const encryptedConnection = new EncryptedConnection(sharedSecret);
+
+        return {
+            success: true,
+            encryptedSharedSecret,
+            encryptedVerifyToken,
+            encryption: encryptedConnection,
+            sharedSecret
+        };
+    }
+}
+
+export default AuthHandler;