@vaitosoi/minejs 0.2.2 → 0.4.0

package/src/base/math.ts

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 
 /** @hidden */
 export const Epsilon = 1.0e-7; // 1^-7
@@ -9,17 +9,39 @@ export const Epsilon = 1.0e-7; // 1^-7
  * Use for offline account
  * 
  * @hidden
+ * @see https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/UUID.java#L165
  */
-export function computeUUID(playerName: string): Buffer {
+export function computeUUID(playerName: string): string {
     const md5 = createHash("md5").update(playerName).digest();
     md5[6]! &= 0x0f;  /* clear version        */
     md5[6]! |= 0x30;  /* set to version 3     */
     md5[8]! &= 0x3f;  /* clear variant        */
     md5[8]! |= 0x80;  /* set to IETF variant  */
+    return md5.toString("hex");
+}
 
-    return md5;
+/**
+ * Create random UUID but in bytes
+ * 
+ * @hidden
+ * @see https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/UUID.java#L144
+ */
+export function randomUUIDBytes(): Buffer {
+    const buffer = randomBytes(16);
+    buffer[6]! &= 0x0f;  /* clear version        */
+    buffer[6]! |= 0x40;  /* set to version 4     */
+    buffer[8]! &= 0x3f;  /* clear variant        */
+    buffer[8]! |= 0x80;  /* set to IETF variant  */
+    return buffer;
 }
 
+/**
+ * Transform UUID string into Buffer
+ * 
+ * @hidden
+ */
+export const uuidToBuffer = (uuid: string) => Buffer.from(uuid.replaceAll("-", ""), "hex");
+
 /** @hidden */
 export const minBigInt = (...args: bigint[]) => args.reduce((min, val) => val < min ? val : min);
 
@@ -60,4 +82,34 @@ export function clamp(a: number, min: number, max: number) {
     if (a < min) return min;
     if (a > max) return max;
     return a;
+}
+
+/**
+ * Compute SHA1 for authenticating client with Mojang server
+ * 
+ * @see https://gist.github.com/andrewrk/4425843?permalink_comment_id=5445918#gistcomment-5445918
+ * @hidden
+ */
+export function minecraftSha1(
+    serverId: string,
+    sharedSecret: Buffer,
+    publicKey: Buffer,
+): string {
+    const sha1 = createHash('sha1');
+    sha1.update(Buffer.from(serverId, 'ascii'));
+    sha1.update(sharedSecret);
+    sha1.update(publicKey);
+
+    return mcHexDigest(sha1.digest());
+}
+
+/**
+ * Compute the hex digest
+ * 
+ * @see https://gist.github.com/andrewrk/4425843?permalink_comment_id=5445918#gistcomment-5445918 
+ * @hidden
+ */
+function mcHexDigest(digest: Buffer | Uint8Array): string {
+    const bigint = BigInt(`0x${digest.toString('hex')}`);
+    return BigInt.asIntN(digest.length * 8, bigint).toString(16);
 }

package/src/base/typing.ts

@@ -1,2 +1,10 @@
 /** @hidden */
-export type If<Condition extends boolean, True, False = null> = Condition extends true ? True : False;
+export type If<Condition extends boolean, True, False = null> = Condition extends true ? True : Condition extends false ? False : True | False;
+
+
+/**
+ * Representing a TextComponent
+ * 
+ * @see https://minecraft.wiki/w/Text_component_format
+ */
+export type TextComponent = Record<string, any>;

package/src/client/auth.ts

@@ -1,21 +1,37 @@
 import http from "node:http";
-import cryto from "node:crypto";
-import net from "node:net";
+import crypto from "node:crypto";
 import { exec } from "node:child_process";
-import { AuthDenied, AuthError, AuthTokenExpired, CantGetMsAccessToken, ProfileError, ProfileNotFound, XboxError } from "../base/error";
+import { AuthDenied, OAuthError, AuthTokenExpired, CantGetMsAccessToken, ProfileError, ProfileNotFound, XboxError, AuthClientError, MinecraftError } from "../base/error";
+import { minecraftSha1 } from "../base/math";
+import { getJson } from "../base/http";
 
-export interface AuthOption {
+interface Loopback {
     /**
-     * `"loopback"` - open a browser to login
-     * `"device_code"` - provide a device code to login
+     * This method will provide you a url to click on and do the authentication.
+     * 
+     * This will require an opening port in order to receive the response from Microsoft. If you cant, considering using `device_code` method.
+     */
+    method: "loopback",
+
+    /**
+     * The opening port for listening the response
      */
-    method: "loopback" | "device_code",
+    port: number
 
     /**
      * Automatedly open browser or print a URL to click on.
      */
     openBrowser: boolean,
+}
 
+interface DeviceCode {
+    /**
+     * This method will provide you a device code, then you have to type this code in the given URL.
+     */
+    method: "device_code",
+}
+
+export type AuthOption = (Loopback | DeviceCode) & {
     /**
      * The Client ID
      * 
@@ -101,17 +117,6 @@ function open(url: string, log: (message: string) => any) {
     }
 }
 
-// Got this from https://github.com/sindresorhus/get-port/blob/main/index.js#L47
-const getFreePort = () => new Promise<number>((resolve) => {
-    const server = net.createServer();
-    server.listen(0, () => {
-        const port = (server.address() as net.AddressInfo).port;
-        server.close(() =>
-            resolve(port)
-        );
-    });
-});
-
 const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
 
 /**
@@ -121,34 +126,100 @@ export class AuthClient {
     private readonly codeVerifier: string;
     private readonly codeChallenge: string;
     // private refreshToken?: string;
+    private accessToken: string = "";
+    private uuid: string = "";
 
     constructor(private option: AuthOption) {
-        const codeVerifier = cryto.randomBytes(32).toString("hex");
-        const hashed = cryto.hash("sha256", codeVerifier, "base64url");
+        const codeVerifier = crypto.randomBytes(32).toString("hex");
+        const hashed = crypto.createHash("sha256").update(codeVerifier).digest("base64url");
         this.option.log ||= console.log;
 
         this.codeVerifier = codeVerifier;
         this.codeChallenge = hashed;
     }
 
-    public async auth() {
+    /**
+     * Send a auth notify to Minecraft server, after receive Encryption Request
+     * 
+     * @see https://minecraft.wiki/w/Java_Edition_protocol/Encryption#Authentication
+     */
+    public async sendAuth(
+        // Sever things
+        serverId: string,
+        sharedSecret: Buffer,
+        publicKey: Buffer,
+    ) {
+        const hash = minecraftSha1(serverId, sharedSecret, publicKey);
+        const response = await fetch(
+            "https://sessionserver.mojang.com/session/minecraft/join",
+            {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                    accessToken: this.accessToken,
+                    selectedProfile: this.uuid,
+                    serverId: hash,
+                })
+            }
+        );
+        console.log({
+            accessToken: this.accessToken,
+            selectedProfile: this.uuid,
+            serverId: hash,
+        });
+        if (response.status === 204) return;
+        const json = await getJson(response, "send auth request") as Record<string, string>;
+        throw new AuthClientError(json["error"]! + ("errorMessage" in json ? `: ${json["errorMessage"]}` : ""));
+    }
+
+    /**
+     * Get player key pair for signing stuff
+     * 
+     * @see https://minecraft.wiki/w/Mojang_API#Get_keypair_for_signature
+     */
+    public async getKeyPair() {
+        const response = await fetch(
+            "https://api.minecraftservices.com/player/certificates",
+            {
+                headers: {
+                    Authorization: `Bearer ${this.accessToken}`
+                }
+            }
+        );
+        if (response.status !== 200) throw new AuthClientError("can't get the auth key", await response.text());
+        const json = await getJson(response, "get key pair") as any;
+        console.log(json);
+        return {
+            publicKey: String(json["keyPair"]["publicKey"]),
+            signature: String(json["publicKeySignatureV2"]),
+            expiresAt: Number(json["expiresAt"]),
+        };
+    }
+
+
+    /**
+     * Get player UUID
+     */
+    public async getUUID() {
         if (this.option.method === "loopback") return this.loopback();
         else return this.deviceCode();
     }
 
     private async loopback() {
-        const freePort = await getFreePort();
-        const expectState = cryto.randomBytes(8).toString("hex");
+        const option = this.option as Loopback;
+        const expectState = crypto.randomBytes(8).toString("hex");
         const authUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize");
         authUrl.searchParams.append("client_id", this.option.client_id);
         authUrl.searchParams.append("response_type", "code");
-        authUrl.searchParams.append("redirect_uri", `http://127.0.0.1:${freePort}`);
+        authUrl.searchParams.append("redirect_uri", `http://localhost:${option.port}`);
         authUrl.searchParams.append("scope", "XboxLive.signin offline_access");
         authUrl.searchParams.append("code_challenge", this.codeChallenge);
         authUrl.searchParams.append("code_challenge_method", "S256");
         authUrl.searchParams.append("state", expectState);
 
-        if (this.option.openBrowser === true)
+        if (option.openBrowser === true)
             open(authUrl.toString(), this.option.log!);
         else
             this.option.log!(`please open this url in your browser: ${authUrl.toString()}`);
@@ -156,32 +227,35 @@ export class AuthClient {
         const msAuthToken = await new Promise<string | null>((resolve) => {
             const server = http.createServer((req, res) => {
                 const end = (html: string, result: any = null) => {
-                    res.end(html);
-                    server.close();
-                    return resolve(result);
+                    if (res.writable)
+                        res.end(html);
+                    if (server.listening) {
+                        server.close();
+                        return resolve(result);
+                    }
                 };
 
-                const url = new URL(req.url || "", `http://127.0.0.1:${freePort}`);
+                const url = new URL(req.url || "", `http://localhost:${option.port}`);
                 const error = url.searchParams.get("error");
                 if (error) {
                     const description = url.searchParams.get("error_description")!;
-                    end(ErrorHTML.replace("{error}", error).replace("{error_description}", description));
+                    return end(ErrorHTML.replace("{error}", error).replace("{error_description}", description));
                 }
 
                 const code = url.searchParams.get("code");
                 if (!code)
-                    end(InvalidHTML.replace("{reason}", "Missing <code>code</code> parameter"));
+                    return end(InvalidHTML.replace("{reason}", "Missing <code>code</code> parameter"));
 
                 const state = url.searchParams.get("state");
                 if (!state)
-                    end(InvalidHTML.replace("{reason}", "Missing <code>state</code> parameter"));
+                    return end(InvalidHTML.replace("{reason}", "Missing <code>state</code> parameter"));
                 if (state !== expectState)
-                    end(InvalidHTML.replace("{reason}", "Mismatch state"));
+                    return end(InvalidHTML.replace("{reason}", "Mismatch state"));
 
                 return end(SuccessHTML, code);
             });
 
-            server.listen(freePort);
+            server.listen(option.port);
         });
 
         if (!msAuthToken)
@@ -190,9 +264,9 @@ export class AuthClient {
         const msTokenUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/token");
         const msTokenBody = new URLSearchParams();
         msTokenBody.append("client_id", this.option.client_id);
-        msTokenBody.append("code", msAuthToken);
         msTokenBody.append("scope", "XboxLive.signin offline_access");
-        msTokenBody.append("redirect_uri", `http://127.0.0.1:${freePort}`);
+        msTokenBody.append("code", msAuthToken);
+        msTokenBody.append("redirect_uri", `http://localhost:${option.port}`);
         msTokenBody.append("grant_type", "authorization_code");
         msTokenBody.append("code_verifier", this.codeVerifier);
         const msTokenRequest = await fetch(msTokenUrl, {
@@ -202,9 +276,9 @@ export class AuthClient {
             method: "POST",
             body: msTokenBody.toString()
         });
-        const msTokenResponse = await msTokenRequest.json() as Record<string, any>;
+        const msTokenResponse = await getJson(msTokenRequest, "microsoft token request") as Record<string, any>;
         if ("error" in msTokenResponse)
-            throw new AuthError(msTokenResponse["error"]);
+            throw new OAuthError(msTokenResponse["error"]);
         const msToken = msTokenResponse["access_token"];
 
         return this.getMcToken(msToken);
@@ -231,7 +305,7 @@ export class AuthClient {
         this.option.log!(message);
 
         let msToken;
-        const msTokenUrl = new URL("https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token");
+        const msTokenUrl = new URL("https://login.microsoftonline.com/consumers/oauth2/v2.0/token");
         const msTokenBody = new URLSearchParams();
         msTokenBody.set("grant_type", "urn:ietf:params:oauth:grant-type:device_code");
         msTokenBody.set("client_id", this.option.client_id);
@@ -240,9 +314,10 @@ export class AuthClient {
             await sleep(interval * 1000);
             const msTokenRequest = await fetch(msTokenUrl, {
                 headers: {
-                    "Content-Type": "application/x-www-form-urlencoded"
+                    "Content-Type": "application/x-www-form-urlencoded",
                 },
-                method: "POST"
+                method: "POST",
+                body: msTokenBody.toString()
             });
             const msTokenResponse = await msTokenRequest.json() as Record<string, any>;
             if ("error" in msTokenResponse)
@@ -251,7 +326,7 @@ export class AuthClient {
                     case "slow_down": interval += 5; continue;
                     case "auth_denied": throw new AuthDenied();
                     case "expired_token": throw new AuthTokenExpired();
-                    default: throw new AuthError(msTokenResponse["error"]);
+                    default: throw new OAuthError(msTokenResponse["error"]);
                 }
             else {
                 msToken = msTokenResponse["access_token"];
@@ -263,10 +338,9 @@ export class AuthClient {
             throw new CantGetMsAccessToken();
 
         return this.getMcToken(msToken);
-    } 
+    }
 
     private async getMcToken(msToken: string): Promise<{
-        token: string,
         uuid: string,
         name: string
     }> {
@@ -287,14 +361,14 @@ export class AuthClient {
             }),
             method: "POST"
         });
-        const xboxReponse = await xboxRequest.json() as Record<string, any>;
+        const xboxReponse = await getJson(xboxRequest, "xbox request") as Record<string, any>;
         const xboxToken = xboxReponse["Token"];
         const userHash = xboxReponse["DisplayClaims"]["xui"][0]["uhs"];
 
         const xboxSecurityRequest = await fetch("https://xsts.auth.xboxlive.com/xsts/authorize", {
             headers: {
                 "Content-Type": "application/json",
-                Accept: "application/json"
+                "Accept": "application/json",
             },
             body: JSON.stringify({
                 "Properties": {
@@ -306,7 +380,7 @@ export class AuthClient {
             }),
             method: "POST"
         });
-        const xboxSecurityReponse = await xboxSecurityRequest.json() as Record<string, any>;
+        const xboxSecurityReponse = await getJson(xboxSecurityRequest, "xbox security request") as Record<string, any>;
         if ("XErr" in xboxSecurityReponse)
             throw new XboxError(xboxSecurityReponse["XErr"]);
         const xboxSecurityToken = xboxSecurityReponse["Token"];
@@ -314,14 +388,17 @@ export class AuthClient {
         const minecraftRequest = await fetch("https://api.minecraftservices.com/authentication/login_with_xbox", {
             headers: {
                 "Content-Type": "application/json",
-                Accept: "application/json"
+                "Accept": "application/json",
+                'User-Agent': 'MinecraftLauncher/2.2.10675'
             },
             body: JSON.stringify({
-                "identityToken": `XBL3.0 x=${userHash};${xboxSecurityToken}"`
+                "identityToken": `XBL3.0 x=${userHash};${xboxSecurityToken}`,
             }),
             method: "POST"
         });
-        const minecraftResponse = await minecraftRequest.json() as Record<string, any>;
+        const minecraftResponse = await getJson(minecraftRequest, "minecraft request") as Record<string, any>;
+        if ("errorMessage" in minecraftResponse)
+            throw new MinecraftError(minecraftResponse["errorMessage"]);
         const minecraftToken = minecraftResponse["access_token"];
 
         const mcProfileRequest = await fetch("https://api.minecraftservices.com/minecraft/profile", {
@@ -330,15 +407,16 @@ export class AuthClient {
             },
             method: "GET"
         });
-        const mcProfileResponse = await mcProfileRequest.json() as Record<string, any>;
+        const mcProfileResponse = await getJson(mcProfileRequest, "minecraft profile request") as Record<string, any>;
         if ("error" in mcProfileResponse) {
             if (mcProfileResponse["error"] === "NOT_FOUND")
                 throw new ProfileNotFound();
             else throw new ProfileError(mcProfileResponse["error"], mcProfileResponse["errorMessage"]);
         }
 
+        this.accessToken = minecraftToken;
+        this.uuid = mcProfileResponse["id"];
         return {
-            token: minecraftToken,
             uuid: mcProfileResponse["id"],
             name: mcProfileResponse["name"]
         };