@jsprismarine/auth 0.0.0-stage → 0.14.1

package/dist/DefaultSkin.cjs.cjs

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/DefaultSkin.ts
+/** A Bedrock skin texture is always RGBA, and 64x64 is the classic layout. */
+var SKIN_WIDTH = 64;
+var SKIN_HEIGHT = 64;
+var BYTES_PER_PIXEL = 4;
+var SKIN_TONE = [
+	200,
+	159,
+	123
+];
+var SHIRT = [
+	63,
+	111,
+	168
+];
+var TROUSERS = [
+	57,
+	63,
+	82
+];
+var REGIONS = [
+	{
+		x: 0,
+		y: 0,
+		width: 32,
+		height: 8,
+		colour: [
+			74,
+			54,
+			40
+		]
+	},
+	{
+		x: 0,
+		y: 8,
+		width: 32,
+		height: 8,
+		colour: SKIN_TONE
+	},
+	{
+		x: 16,
+		y: 16,
+		width: 24,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 40,
+		y: 16,
+		width: 16,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 32,
+		y: 48,
+		width: 16,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 0,
+		y: 16,
+		width: 16,
+		height: 16,
+		colour: TROUSERS
+	},
+	{
+		x: 16,
+		y: 48,
+		width: 16,
+		height: 16,
+		colour: TROUSERS
+	}
+];
+/**
+* The skin the client wears when nothing else has been supplied.
+*
+* Generated rather than shipped as a PNG, and generated from flat colour blocks that are
+* ours: Mojang's textures cannot be redistributed, and a client that refuses to log in
+* without one would be useless. It is deliberately plain - the point is a valid, original
+* 16 KiB of RGBA, not a good-looking character.
+*
+* @returns 64 * 64 * 4 bytes of RGBA, row major from the top left.
+*/
+var createDefaultSkinImage = () => {
+	const image = Buffer.alloc(4096 * BYTES_PER_PIXEL);
+	for (const region of REGIONS) for (let y = region.y; y < region.y + region.height; y++) for (let x = region.x; x < region.x + region.width; x++) {
+		const offset = (y * 64 + x) * BYTES_PER_PIXEL;
+		const shade = 1 - (y - region.y) / region.height * .15;
+		image[offset] = Math.round(region.colour[0] * shade);
+		image[offset + 1] = Math.round(region.colour[1] * shade);
+		image[offset + 2] = Math.round(region.colour[2] * shade);
+		image[offset + 3] = 255;
+	}
+	return image;
+};
+/**
+* Which model the client should hang the texture on.
+*
+* `geometry.humanoid.custom` is resolved by the client against a model it already has, so
+* this is a reference rather than geometry we would have to ship. `SkinGeometryData` stays
+* empty for the same reason.
+*/
+var DEFAULT_SKIN_RESOURCE_PATCH = JSON.stringify({ geometry: { default: "geometry.humanoid.custom" } });
+exports.DEFAULT_SKIN_RESOURCE_PATCH = DEFAULT_SKIN_RESOURCE_PATCH;
+exports.SKIN_HEIGHT = SKIN_HEIGHT;
+exports.SKIN_WIDTH = SKIN_WIDTH;
+exports.createDefaultSkinImage = createDefaultSkinImage;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/DefaultSkin.d.ts

@@ -0,0 +1,23 @@
+/** A Bedrock skin texture is always RGBA, and 64x64 is the classic layout. */
+export declare const SKIN_WIDTH = 64;
+export declare const SKIN_HEIGHT = 64;
+/**
+ * The skin the client wears when nothing else has been supplied.
+ *
+ * Generated rather than shipped as a PNG, and generated from flat colour blocks that are
+ * ours: Mojang's textures cannot be redistributed, and a client that refuses to log in
+ * without one would be useless. It is deliberately plain - the point is a valid, original
+ * 16 KiB of RGBA, not a good-looking character.
+ *
+ * @returns 64 * 64 * 4 bytes of RGBA, row major from the top left.
+ */
+export declare const createDefaultSkinImage: () => Buffer;
+/**
+ * Which model the client should hang the texture on.
+ *
+ * `geometry.humanoid.custom` is resolved by the client against a model it already has, so
+ * this is a reference rather than geometry we would have to ship. `SkinGeometryData` stays
+ * empty for the same reason.
+ */
+export declare const DEFAULT_SKIN_RESOURCE_PATCH: string;
+//# sourceMappingURL=DefaultSkin.d.ts.map

package/dist/DefaultSkin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefaultSkin.d.ts","sourceRoot":"","sources":["../src/DefaultSkin.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,WAAW,KAAK,CAAC;AAsC9B;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,QAAO,MAmBzC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,QAEtC,CAAC"}

package/dist/DefaultSkin.es.js

@@ -0,0 +1,108 @@
+// src/DefaultSkin.ts
+/** A Bedrock skin texture is always RGBA, and 64x64 is the classic layout. */
+var SKIN_WIDTH = 64;
+var SKIN_HEIGHT = 64;
+var BYTES_PER_PIXEL = 4;
+var SKIN_TONE = [
+	200,
+	159,
+	123
+];
+var SHIRT = [
+	63,
+	111,
+	168
+];
+var TROUSERS = [
+	57,
+	63,
+	82
+];
+var REGIONS = [
+	{
+		x: 0,
+		y: 0,
+		width: 32,
+		height: 8,
+		colour: [
+			74,
+			54,
+			40
+		]
+	},
+	{
+		x: 0,
+		y: 8,
+		width: 32,
+		height: 8,
+		colour: SKIN_TONE
+	},
+	{
+		x: 16,
+		y: 16,
+		width: 24,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 40,
+		y: 16,
+		width: 16,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 32,
+		y: 48,
+		width: 16,
+		height: 16,
+		colour: SHIRT
+	},
+	{
+		x: 0,
+		y: 16,
+		width: 16,
+		height: 16,
+		colour: TROUSERS
+	},
+	{
+		x: 16,
+		y: 48,
+		width: 16,
+		height: 16,
+		colour: TROUSERS
+	}
+];
+/**
+* The skin the client wears when nothing else has been supplied.
+*
+* Generated rather than shipped as a PNG, and generated from flat colour blocks that are
+* ours: Mojang's textures cannot be redistributed, and a client that refuses to log in
+* without one would be useless. It is deliberately plain - the point is a valid, original
+* 16 KiB of RGBA, not a good-looking character.
+*
+* @returns 64 * 64 * 4 bytes of RGBA, row major from the top left.
+*/
+var createDefaultSkinImage = () => {
+	const image = Buffer.alloc(4096 * BYTES_PER_PIXEL);
+	for (const region of REGIONS) for (let y = region.y; y < region.y + region.height; y++) for (let x = region.x; x < region.x + region.width; x++) {
+		const offset = (y * 64 + x) * BYTES_PER_PIXEL;
+		const shade = 1 - (y - region.y) / region.height * .15;
+		image[offset] = Math.round(region.colour[0] * shade);
+		image[offset + 1] = Math.round(region.colour[1] * shade);
+		image[offset + 2] = Math.round(region.colour[2] * shade);
+		image[offset + 3] = 255;
+	}
+	return image;
+};
+/**
+* Which model the client should hang the texture on.
+*
+* `geometry.humanoid.custom` is resolved by the client against a model it already has, so
+* this is a reference rather than geometry we would have to ship. `SkinGeometryData` stays
+* empty for the same reason.
+*/
+var DEFAULT_SKIN_RESOURCE_PATCH = JSON.stringify({ geometry: { default: "geometry.humanoid.custom" } });
+export { DEFAULT_SKIN_RESOURCE_PATCH, SKIN_HEIGHT, SKIN_WIDTH, createDefaultSkinImage };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/IAuthProvider.cjs.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });

package/dist/IAuthProvider.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The two JWT blobs a `Login` packet carries.
+ *
+ * Deliberately the *encoded* form rather than the data behind it: an offline provider signs
+ * these itself, and an Xbox one receives most of the chain already signed by Mojang and
+ * cannot reconstruct it. What they have in common is the pair of strings that goes on the
+ * wire, so that is what the interface is about.
+ */
+export interface LoginCredentials {
+    /**
+     * `{"chain": [...]}` - one JWT per link. Offline that is a single self-signed token;
+     * authenticated it is the client's own token followed by Mojang's.
+     */
+    readonly chainData: string;
+    /** One JWT: skin, device, language, and the address the client thinks it dialled. */
+    readonly clientData: string;
+}
+/** Who the player is, as far as the login is concerned. */
+export interface Identity {
+    /** Empty when not authenticated. A server in online mode refuses that. */
+    readonly xuid: string;
+    /** The uuid the client is known by. The server rejects a login with no identity. */
+    readonly identity: string;
+    readonly displayName: string;
+    readonly titleId?: string;
+}
+export interface LoginRequest {
+    /** Where we are connecting, as the client reports it: `host:port`. */
+    readonly serverAddress: string;
+    /** The protocol version being spoken, echoed into the client data. */
+    readonly protocolVersion: number;
+}
+/**
+ * Where a login identity comes from.
+ *
+ * The seam exists so that what the bot harness needs - hundreds of throwaway identities, no
+ * network, no token cache - and what a real client needs are the same shape to everything
+ * upstream. It is also what keeps Xbox Live out of the headless build: a provider is chosen
+ * at the edge, and nothing in the client core imports one.
+ */
+export interface IAuthProvider {
+    /** For logs and for choosing between cached sessions. */
+    readonly name: string;
+    /**
+     * The identity this provider will log in as.
+     *
+     * Available before {@link createLoginCredentials} so a caller can label a connection
+     * before it has made one - a bot harness reporting which of five hundred it is waiting
+     * on, say.
+     */
+    getIdentity(): Promise<Identity>;
+    /**
+     * Signs, or fetches, the credentials for one login.
+     *
+     * Called once per connection attempt rather than cached, because the client data
+     * carries the address being dialled and the chain carries an expiry.
+     */
+    createLoginCredentials(request: LoginRequest): Promise<LoginCredentials>;
+    /**
+     * The public half of the key the chain is signed with, DER encoded and base64'd - the
+     * same string the chain's `identityPublicKey` claim carries.
+     *
+     * Encryption derives its shared secret from this key, so a provider has to expose it
+     * even though nothing in the login itself asks for it separately.
+     */
+    getIdentityPublicKey(): Promise<string>;
+    /**
+     * The private key, for the ECDH half of the encryption handshake.
+     *
+     * Returned as a PEM-encoded PKCS#8 string rather than a `KeyObject` so that a provider
+     * backed by something that is not node's crypto stays possible.
+     */
+    getIdentityPrivateKey(): Promise<string>;
+}
+//# sourceMappingURL=IAuthProvider.d.ts.map

package/dist/IAuthProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IAuthProvider.d.ts","sourceRoot":"","sources":["../src/IAuthProvider.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,qFAAqF;IACrF,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B;AAED,2DAA2D;AAC3D,MAAM,WAAW,QAAQ;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,YAAY;IACzB,sEAAsE;IACtE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,sEAAsE;IACtE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC1B,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;OAMG;IACH,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEjC;;;;;OAKG;IACH,sBAAsB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEzE;;;;;;OAMG;IACH,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAExC;;;;;OAKG;IACH,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CAC5C"}

package/dist/OfflineAuthProvider.cjs.cjs

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+const require_ClientData = require("./ClientData.cjs.cjs");
+let fast_jwt = require("fast-jwt");
+let node_crypto = require("node:crypto");
+// src/OfflineAuthProvider.ts
+/**
+* The curve Bedrock's identity keys use, and the JOSE algorithm that goes with it. Not
+* configurable: a server derives its encryption secret from this key, so both ends have to
+* agree, and the protocol fixes the answer.
+*/
+var CURVE = "secp384r1";
+var ALGORITHM = "ES384";
+/** How long a self-signed chain claims to be valid for. */
+var CHAIN_LIFETIME_SECONDS = 21600;
+/**
+* The first protocol whose servers want a multiplayer token rather than a certificate chain.
+*
+* 1.26.10 moved the offline identity out of the chain: what used to be a self-signed link
+* carrying `extraData` is now a self-signed OIDC token in a `Token` field beside a chain that
+* exists only to hold its place. A server at or past this refuses the old shape - and refuses
+* it by going quiet at the RakNet layer rather than by answering, which is why the version
+* this compares against is worth stating rather than discovering.
+*/
+var FIRST_TOKEN_PROTOCOL = 944;
+/** What the token says it is for. A server checks the audience even when it verifies nothing else. */
+var MULTIPLAYER_AUDIENCE = "api://auth-minecraft-services/multiplayer";
+/** The value naming a self-signed identity, as opposed to one Xbox Live vouched for. */
+var AUTHENTICATION_TYPE_SELF_SIGNED = 2;
+/**
+* A login identity that talks to nothing.
+*
+* The chain is a single JWT this provider signs with a key it just generated, which is
+* exactly what the real client sends when it is not signed in to Xbox Live. A server in
+* online mode refuses it - there is no XUID to check, and it says so - and a server with
+* `online-mode` off accepts it, which covers JSPrismarine itself, a LAN game, and the
+* whole of the bot harness.
+*
+* The key is generated per instance rather than per login. It is the identity: reusing one
+* across two concurrent connections would have them claim to be the same client, and the
+* encryption handshake would derive the same secret for both.
+*
+* @example
+* ```typescript
+* const auth = new OfflineAuthProvider({ displayName: 'Steve' });
+* const credentials = await auth.createLoginCredentials({ serverAddress: '127.0.0.1:19132', protocolVersion: 748 });
+* ```
+*/
+var OfflineAuthProvider = class {
+	options;
+	name = "offline";
+	identity;
+	privateKeyPem;
+	publicKeyDer;
+	clientRandomId;
+	constructor(options) {
+		this.options = options;
+		const { publicKey, privateKey } = (0, node_crypto.generateKeyPairSync)("ec", { namedCurve: CURVE });
+		this.publicKeyDer = publicKey.export({
+			type: "spki",
+			format: "der"
+		}).toString("base64");
+		this.privateKeyPem = privateKey.export({
+			type: "pkcs8",
+			format: "pem"
+		}).toString();
+		this.identity = {
+			xuid: "",
+			identity: options.identity ?? (0, node_crypto.randomUUID)(),
+			displayName: options.displayName
+		};
+		this.clientRandomId = (0, node_crypto.randomInt)(0, 2147483647);
+	}
+	async getIdentity() {
+		return this.identity;
+	}
+	async getIdentityPublicKey() {
+		return this.publicKeyDer;
+	}
+	async getIdentityPrivateKey() {
+		return this.privateKeyPem;
+	}
+	async createLoginCredentials(request) {
+		return {
+			chainData: request.protocolVersion >= FIRST_TOKEN_PROTOCOL ? this.signTokenRequest() : JSON.stringify({ chain: [this.signChainLink()] }),
+			clientData: this.signClientData(request)
+		};
+	}
+	/**
+	* The identity as a server from 1.26.10 on wants it.
+	*
+	* The chain is one empty string. That is not a placeholder for something missing: the
+	* field is still read, and an offline client has no certificate to put in it, so it holds
+	* a link that says nothing while the `Token` beside it carries the identity. `Certificate`
+	* is a *string* of JSON rather than an object, which is the shape the server parses.
+	*/
+	signTokenRequest() {
+		return JSON.stringify({
+			Certificate: JSON.stringify({ chain: [""] }),
+			AuthenticationType: AUTHENTICATION_TYPE_SELF_SIGNED,
+			Token: this.signMultiplayerToken()
+		});
+	}
+	/**
+	* The self-signed token that replaced the chain link.
+	*
+	* The claim names are short and unobvious because they are an identity provider's, not
+	* Minecraft's: `cpk` is the key the encryption handshake will use, `xid` the Xbox id an
+	* offline player does not have, `leguuid` the uuid that has to stand in for it. The
+	* PlayFab fields are sent empty rather than omitted, because a real client always sends
+	* them and a field that is present-and-empty is the smaller departure from that.
+	*/
+	signMultiplayerToken() {
+		const now = Math.floor(Date.now() / 1e3);
+		return (0, fast_jwt.createSigner)({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			}
+		})({
+			aud: MULTIPLAYER_AUDIENCE,
+			nbf: now - CHAIN_LIFETIME_SECONDS,
+			exp: now + CHAIN_LIFETIME_SECONDS,
+			iat: now,
+			ipt: "",
+			mid: "",
+			tid: "",
+			cpk: this.publicKeyDer,
+			xid: this.identity.xuid,
+			xname: this.identity.displayName,
+			leguuid: this.identity.identity
+		});
+	}
+	/**
+	* The one link an unauthenticated chain has: self-signed, and vouching for nothing but
+	* itself.
+	*
+	* The `x5u` header and the `identityPublicKey` claim are the same key, which is how a
+	* verifier knows the token signed itself. An authenticated chain has Mojang's key in
+	* `x5u` and this one in the claim, and the difference between the two is the whole of
+	* what online mode checks.
+	*/
+	signChainLink() {
+		const now = Math.floor(Date.now() / 1e3);
+		return (0, fast_jwt.createSigner)({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			}
+		})({
+			nbf: now - 60,
+			exp: now + CHAIN_LIFETIME_SECONDS,
+			iat: now,
+			identityPublicKey: this.publicKeyDer,
+			extraData: {
+				XUID: this.identity.xuid,
+				identity: this.identity.identity,
+				displayName: this.identity.displayName,
+				titleId: this.identity.titleId ?? ""
+			}
+		});
+	}
+	signClientData(request) {
+		return (0, fast_jwt.createSigner)({
+			algorithm: ALGORITHM,
+			key: this.privateKeyPem,
+			header: {
+				alg: ALGORITHM,
+				x5u: this.publicKeyDer
+			},
+			noTimestamp: true
+		})(require_ClientData.createClientData({
+			...this.options.clientData,
+			serverAddress: request.serverAddress,
+			clientRandomId: this.clientRandomId,
+			selfSignedId: this.identity.identity,
+			displayName: this.identity.displayName
+		}));
+	}
+};
+exports.default = OfflineAuthProvider;
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"OfflineAuthProvider.cjs.cjs","names":["generateKeyPairSync","randomUUID","randomInt","createSigner","createClientData"],"sources":["../src/OfflineAuthProvider.ts"],"sourcesContent":["import { createSigner } from 'fast-jwt';\nimport { generateKeyPairSync, randomInt, randomUUID } from 'node:crypto';\nimport type { ClientDataOptions } from './ClientData';\nimport { createClientData } from './ClientData';\n\nimport type { IAuthProvider, Identity, LoginCredentials, LoginRequest } from './IAuthProvider';\n\n/**\n * The curve Bedrock's identity keys use, and the JOSE algorithm that goes with it. Not\n * configurable: a server derives its encryption secret from this key, so both ends have to\n * agree, and the protocol fixes the answer.\n */\nconst CURVE = 'secp384r1';\nconst ALGORITHM = 'ES384';\n\n/** How long a self-signed chain claims to be valid for. */\nconst CHAIN_LIFETIME_SECONDS = 6 * 60 * 60;\n\n/**\n * The first protocol whose servers want a multiplayer token rather than a certificate chain.\n *\n * 1.26.10 moved the offline identity out of the chain: what used to be a self-signed link\n * carrying `extraData` is now a self-signed OIDC token in a `Token` field beside a chain that\n * exists only to hold its place. A server at or past this refuses the old shape - and refuses\n * it by going quiet at the RakNet layer rather than by answering, which is why the version\n * this compares against is worth stating rather than discovering.\n */\nconst FIRST_TOKEN_PROTOCOL = 944;\n\n/** What the token says it is for. A server checks the audience even when it verifies nothing else. */\nconst MULTIPLAYER_AUDIENCE = 'api://auth-minecraft-services/multiplayer';\n\n/** The value naming a self-signed identity, as opposed to one Xbox Live vouched for. */\nconst AUTHENTICATION_TYPE_SELF_SIGNED = 2;\n\nexport interface OfflineAuthOptions {\n    /** The name that shows up in chat and the player list. */\n    readonly displayName: string;\n    /**\n     * The uuid the server knows this player by, stable across reconnects if you supply it.\n     *\n     * Worth supplying for a client with a world to come back to, and worth *not* supplying\n     * for a bot fleet, where five hundred connections each need their own.\n     */\n    readonly identity?: string;\n    readonly clientData?: Partial<ClientDataOptions>;\n}\n\n/**\n * A login identity that talks to nothing.\n *\n * The chain is a single JWT this provider signs with a key it just generated, which is\n * exactly what the real client sends when it is not signed in to Xbox Live. A server in\n * online mode refuses it - there is no XUID to check, and it says so - and a server with\n * `online-mode` off accepts it, which covers JSPrismarine itself, a LAN game, and the\n * whole of the bot harness.\n *\n * The key is generated per instance rather than per login. It is the identity: reusing one\n * across two concurrent connections would have them claim to be the same client, and the\n * encryption handshake would derive the same secret for both.\n *\n * @example\n * ```typescript\n * const auth = new OfflineAuthProvider({ displayName: 'Steve' });\n * const credentials = await auth.createLoginCredentials({ serverAddress: '127.0.0.1:19132', protocolVersion: 748 });\n * ```\n */\nexport default class OfflineAuthProvider implements IAuthProvider {\n    public readonly name = 'offline';\n\n    private readonly identity: Identity;\n    private readonly privateKeyPem: string;\n    private readonly publicKeyDer: string;\n    private readonly clientRandomId: number;\n\n    public constructor(private readonly options: OfflineAuthOptions) {\n        const { publicKey, privateKey } = generateKeyPairSync('ec', { namedCurve: CURVE });\n\n        // DER inside base64, which is the form both the `x5u` header and the\n        // `identityPublicKey` claim carry - not PEM, and not a JWK.\n        this.publicKeyDer = publicKey.export({ type: 'spki', format: 'der' }).toString('base64');\n        this.privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();\n\n        this.identity = {\n            // Empty, and that is the point: an XUID is what an offline client cannot have,\n            // and it is what a server in online mode checks for.\n            xuid: '',\n            identity: options.identity ?? randomUUID(),\n            displayName: options.displayName\n        };\n\n        // Mojang's is a signed 32 bit value the client picks once per session and the\n        // server stores against the player; nothing derives from it.\n        this.clientRandomId = randomInt(0, 0x7fffffff);\n    }\n\n    public async getIdentity(): Promise<Identity> {\n        return this.identity;\n    }\n\n    public async getIdentityPublicKey(): Promise<string> {\n        return this.publicKeyDer;\n    }\n\n    public async getIdentityPrivateKey(): Promise<string> {\n        return this.privateKeyPem;\n    }\n\n    public async createLoginCredentials(request: LoginRequest): Promise<LoginCredentials> {\n        return {\n            chainData:\n                request.protocolVersion >= FIRST_TOKEN_PROTOCOL\n                    ? this.signTokenRequest()\n                    : JSON.stringify({ chain: [this.signChainLink()] }),\n            clientData: this.signClientData(request)\n        };\n    }\n\n    /**\n     * The identity as a server from 1.26.10 on wants it.\n     *\n     * The chain is one empty string. That is not a placeholder for something missing: the\n     * field is still read, and an offline client has no certificate to put in it, so it holds\n     * a link that says nothing while the `Token` beside it carries the identity. `Certificate`\n     * is a *string* of JSON rather than an object, which is the shape the server parses.\n     */\n    private signTokenRequest(): string {\n        return JSON.stringify({\n            Certificate: JSON.stringify({ chain: [''] }),\n            AuthenticationType: AUTHENTICATION_TYPE_SELF_SIGNED,\n            Token: this.signMultiplayerToken()\n        });\n    }\n\n    /**\n     * The self-signed token that replaced the chain link.\n     *\n     * The claim names are short and unobvious because they are an identity provider's, not\n     * Minecraft's: `cpk` is the key the encryption handshake will use, `xid` the Xbox id an\n     * offline player does not have, `leguuid` the uuid that has to stand in for it. The\n     * PlayFab fields are sent empty rather than omitted, because a real client always sends\n     * them and a field that is present-and-empty is the smaller departure from that.\n     */\n    private signMultiplayerToken(): string {\n        const now = Math.floor(Date.now() / 1000);\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer }\n        });\n\n        return sign({\n            aud: MULTIPLAYER_AUDIENCE,\n            nbf: now - CHAIN_LIFETIME_SECONDS,\n            exp: now + CHAIN_LIFETIME_SECONDS,\n            iat: now,\n            ipt: '',\n            mid: '',\n            tid: '',\n            cpk: this.publicKeyDer,\n            xid: this.identity.xuid,\n            xname: this.identity.displayName,\n            leguuid: this.identity.identity\n        });\n    }\n\n    /**\n     * The one link an unauthenticated chain has: self-signed, and vouching for nothing but\n     * itself.\n     *\n     * The `x5u` header and the `identityPublicKey` claim are the same key, which is how a\n     * verifier knows the token signed itself. An authenticated chain has Mojang's key in\n     * `x5u` and this one in the claim, and the difference between the two is the whole of\n     * what online mode checks.\n     */\n    private signChainLink(): string {\n        const now = Math.floor(Date.now() / 1000);\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer }\n        });\n\n        return sign({\n            nbf: now - 60,\n            exp: now + CHAIN_LIFETIME_SECONDS,\n            iat: now,\n            identityPublicKey: this.publicKeyDer,\n            extraData: {\n                XUID: this.identity.xuid,\n                identity: this.identity.identity,\n                displayName: this.identity.displayName,\n                titleId: this.identity.titleId ?? ''\n            }\n        });\n    }\n\n    private signClientData(request: LoginRequest): string {\n        const sign = createSigner({\n            algorithm: ALGORITHM,\n            key: this.privateKeyPem,\n            header: { alg: ALGORITHM, x5u: this.publicKeyDer },\n            noTimestamp: true\n        });\n\n        return sign(\n            createClientData({\n                ...this.options.clientData,\n                serverAddress: request.serverAddress,\n                clientRandomId: this.clientRandomId,\n                selfSignedId: this.identity.identity,\n                displayName: this.identity.displayName\n            })\n        );\n    }\n}\n"],"mappings":"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"}

package/dist/OfflineAuthProvider.d.ts

@@ -0,0 +1,77 @@
+import type { ClientDataOptions } from './ClientData';
+import type { IAuthProvider, Identity, LoginCredentials, LoginRequest } from './IAuthProvider';
+export interface OfflineAuthOptions {
+    /** The name that shows up in chat and the player list. */
+    readonly displayName: string;
+    /**
+     * The uuid the server knows this player by, stable across reconnects if you supply it.
+     *
+     * Worth supplying for a client with a world to come back to, and worth *not* supplying
+     * for a bot fleet, where five hundred connections each need their own.
+     */
+    readonly identity?: string;
+    readonly clientData?: Partial<ClientDataOptions>;
+}
+/**
+ * A login identity that talks to nothing.
+ *
+ * The chain is a single JWT this provider signs with a key it just generated, which is
+ * exactly what the real client sends when it is not signed in to Xbox Live. A server in
+ * online mode refuses it - there is no XUID to check, and it says so - and a server with
+ * `online-mode` off accepts it, which covers JSPrismarine itself, a LAN game, and the
+ * whole of the bot harness.
+ *
+ * The key is generated per instance rather than per login. It is the identity: reusing one
+ * across two concurrent connections would have them claim to be the same client, and the
+ * encryption handshake would derive the same secret for both.
+ *
+ * @example
+ * ```typescript
+ * const auth = new OfflineAuthProvider({ displayName: 'Steve' });
+ * const credentials = await auth.createLoginCredentials({ serverAddress: '127.0.0.1:19132', protocolVersion: 748 });
+ * ```
+ */
+export default class OfflineAuthProvider implements IAuthProvider {
+    private readonly options;
+    readonly name = "offline";
+    private readonly identity;
+    private readonly privateKeyPem;
+    private readonly publicKeyDer;
+    private readonly clientRandomId;
+    constructor(options: OfflineAuthOptions);
+    getIdentity(): Promise<Identity>;
+    getIdentityPublicKey(): Promise<string>;
+    getIdentityPrivateKey(): Promise<string>;
+    createLoginCredentials(request: LoginRequest): Promise<LoginCredentials>;
+    /**
+     * The identity as a server from 1.26.10 on wants it.
+     *
+     * The chain is one empty string. That is not a placeholder for something missing: the
+     * field is still read, and an offline client has no certificate to put in it, so it holds
+     * a link that says nothing while the `Token` beside it carries the identity. `Certificate`
+     * is a *string* of JSON rather than an object, which is the shape the server parses.
+     */
+    private signTokenRequest;
+    /**
+     * The self-signed token that replaced the chain link.
+     *
+     * The claim names are short and unobvious because they are an identity provider's, not
+     * Minecraft's: `cpk` is the key the encryption handshake will use, `xid` the Xbox id an
+     * offline player does not have, `leguuid` the uuid that has to stand in for it. The
+     * PlayFab fields are sent empty rather than omitted, because a real client always sends
+     * them and a field that is present-and-empty is the smaller departure from that.
+     */
+    private signMultiplayerToken;
+    /**
+     * The one link an unauthenticated chain has: self-signed, and vouching for nothing but
+     * itself.
+     *
+     * The `x5u` header and the `identityPublicKey` claim are the same key, which is how a
+     * verifier knows the token signed itself. An authenticated chain has Mojang's key in
+     * `x5u` and this one in the claim, and the difference between the two is the whole of
+     * what online mode checks.
+     */
+    private signChainLink;
+    private signClientData;
+}
+//# sourceMappingURL=OfflineAuthProvider.d.ts.map

package/dist/OfflineAuthProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineAuthProvider.d.ts","sourceRoot":"","sources":["../src/OfflineAuthProvider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGtD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AA8B/F,MAAM,WAAW,kBAAkB;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,OAAO,OAAO,mBAAoB,YAAW,aAAa;IAQ1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP3C,SAAgB,IAAI,aAAa;IAEjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IAExC,YAAoC,OAAO,EAAE,kBAAkB,EAmB9D;IAEY,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC,CAE5C;IAEY,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAEnD;IAEY,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,CAEpD;IAEY,sBAAsB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAQpF;IAED;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IAQxB;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;IAuB5B;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,cAAc;CAkBzB"}