@epicauth/sdk 0.1.3

package/LICENSE

@@ -0,0 +1,94 @@
+
+Elastic License 2.0
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject to
+the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices
+of the licensor in the software. Any use of the licensor’s trademarks is subject
+to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you
+also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is the
+software the licensor makes available under these terms, including any portion
+of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that
+organization. **control** means ownership of substantially all the assets of an
+entity, or the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,15 @@
+# epicauth-ts-example
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run index.ts
+```
+
+This project was created using `bun init` in bun v1.3.13. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.

package/dist/client.d.ts

@@ -0,0 +1,45 @@
+import type { EpicAuthAppData, EpicAuthOptions, EpicAuthUserData } from "./types/types";
+import type { LicenseOptions, LoginOptions } from "./types/inputs";
+export default class EpicAuth {
+    private name;
+    private ownerid;
+    private version;
+    private hash_to_check?;
+    private url;
+    private path?;
+    private exitOnError?;
+    private sessionid?;
+    private initialized;
+    private public_key;
+    private loggingEnabled;
+    user_data: EpicAuthUserData | null;
+    app_data: EpicAuthAppData | null;
+    constructor(options: EpicAuthOptions);
+    Init(): Promise<undefined>;
+    /**
+   * Login to EpicAuth using a username and password.
+   *
+   * @param username User's username.
+   * @param password User's password.
+   * @param code Optional 2FA code if exist.
+   * @param hwid Optional custom HWID.
+   *
+   */
+    login({ username, password, code, hwid }: LoginOptions): Promise<undefined>;
+    /**
+     * Login to EpicAuth Using a license key.
+     *
+     * @param license License key
+     * @param code Optional 2FA code if exist.
+     * @param hwid Optional custom HWID.
+     */
+    license({ license, code, hwid }: LicenseOptions): Promise<undefined>;
+    checkinit(): Promise<undefined>;
+    getHWID(): string;
+    private fail;
+    private sleep;
+    private request;
+    private logEvent;
+    private redactField;
+    private load_user_data;
+}

package/dist/client.js

@@ -0,0 +1,351 @@
+import { EpicAuthError } from "./errors";
+import crypto from "crypto";
+import * as ed from "@noble/ed25519";
+import fs from "fs";
+import { execSync, exec } from "child_process";
+import os from "os";
+import { createInterface } from "readline";
+import path from "node:path";
+import { sha512 } from "@noble/hashes/sha2.js";
+ed.hashes.sha512 = (...msgs) => sha512(ed.etc.concatBytes(...msgs));
+const readline = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false,
+});
+export default class EpicAuth {
+    name;
+    ownerid;
+    version;
+    hash_to_check;
+    url = "https://epicauth.cc/api/1.3/";
+    path;
+    exitOnError = true;
+    sessionid;
+    initialized = false;
+    public_key = "95b38710f40927b16528a073b87d942e03bd4578d49963a19ebae177945f89ac";
+    loggingEnabled = true;
+    user_data = null;
+    app_data = null;
+    constructor(options) {
+        this.name = options.name;
+        this.ownerid = options.ownerid;
+        this.version = options.version;
+        this.hash_to_check = options.hash_to_check;
+        this.url = options.url ?? "https://epicauth.cc/api/1.3/";
+        this.path = options.path;
+        this.loggingEnabled = options.loggingEnabled ?? true;
+        this.exitOnError = options.exitOnError ?? true;
+        if (!this.name || !this.ownerid || !this.version) {
+            throw new Error("Name, ownerid, and version are required");
+        }
+    }
+    async Init() {
+        if (!this.sessionid && this.initialized) {
+            return this.fail("Application already initialized", 0);
+        }
+        let token = "";
+        if (this.path) {
+            try {
+                token = fs.readFileSync(this.path, "utf-8").trim();
+            }
+            catch (error) {
+                return this.fail(`Failed to read file at path ${this.path}: ${error}`, 0);
+            }
+        }
+        const body = {
+            "type": "init",
+            "ownerid": this.ownerid,
+            "version": this.version,
+            "name": this.name,
+            "hash": this.hash_to_check,
+            ...this.path && {
+                "token": token,
+                "thash": crypto.createHash("sha256").update(token).digest("hex"),
+            }
+        };
+        const response = await this.request(body);
+        if (response === "EpicAuth_Invalid") {
+            return this.fail("This application does not exist");
+        }
+        if (response["message"] === "invalidver") {
+            if ("download" in response) {
+                console.log("Your application is outdated.");
+                exec(`start ${response["download"]}`, (error) => {
+                    if (error) {
+                        return this.fail(`Failed to open the download link:${error}`);
+                    }
+                });
+                return this.fail('use latest update');
+            }
+            else {
+                return this.fail("Your application is outdated and no download link was provided, contact the owner for the latest app version.");
+            }
+        }
+        if (response['success'] === false) {
+            return this.fail(response['message']);
+        }
+        if ("sessionid" in response) {
+            this.sessionid = response.sessionid;
+            this.initialized = true;
+        }
+    }
+    /**
+   * Login to EpicAuth using a username and password.
+   *
+   * @param username User's username.
+   * @param password User's password.
+   * @param code Optional 2FA code if exist.
+   * @param hwid Optional custom HWID.
+   *
+   */
+    async login({ username, password, code, hwid }) {
+        this.checkinit();
+        if (!hwid)
+            hwid = this.getHWID();
+        const body = {
+            "type": "login",
+            "name": this.name,
+            "ownerid": this.ownerid,
+            "sessionid": this.sessionid,
+            "username": username,
+            "pass": password,
+            "hwid": hwid,
+            ...code && { "code": code },
+        };
+        const response = await this.request(body);
+        if (response["success"] === true) {
+            console.log(response["message"]);
+            this.load_user_data(response["info"]);
+        }
+        else {
+            console.log(response["message"]);
+            return this.fail(response['message']);
+        }
+    }
+    /**
+     * Login to EpicAuth Using a license key.
+     *
+     * @param license License key
+     * @param code Optional 2FA code if exist.
+     * @param hwid Optional custom HWID.
+     */
+    async license({ license, code, hwid }) {
+        this.checkinit();
+        if (!hwid)
+            hwid = this.getHWID();
+        const body = {
+            "type": "license",
+            "name": this.name,
+            "ownerid": this.ownerid,
+            "sessionid": this.sessionid,
+            "key": license,
+            "hwid": hwid,
+            ...code && { "code": code },
+        };
+        const response = await this.request(body);
+        if (response["success"] === true) {
+            console.log(response["message"]);
+            this.load_user_data(response["info"]);
+        }
+        else {
+            console.log(response["message"]);
+            return this.fail(response['message']);
+        }
+    }
+    async checkinit() {
+        if (!this.sessionid && !this.initialized) {
+            return this.fail("You need to run the EpicAuthApp.init(); function before any other EpicAuth functions");
+        }
+    }
+    getHWID() {
+        const platform = os.platform();
+        try {
+            switch (platform) {
+                case "linux":
+                    // Linux: (machine-id)
+                    try {
+                        const machineId = fs.readFileSync("/etc/machine-id", "utf-8").trim();
+                        if (machineId && machineId.length > 10) {
+                            return machineId;
+                        }
+                    }
+                    catch {
+                        // Fallback
+                        try {
+                            const dbus = fs.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim();
+                            if (dbus)
+                                return dbus;
+                        }
+                        catch { }
+                    }
+                    break;
+                case "win32":
+                    // Windows: Machine GUID 
+                    try {
+                        const guid = execSync('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', { stdio: "pipe" }).toString();
+                        const match = guid.match(/MachineGuid\s+REG_SZ\s+([a-zA-Z0-9-]+)/);
+                        if (match && match[1]) {
+                            return match[1];
+                        }
+                    }
+                    catch { }
+                    // Fallback to SID
+                    try {
+                        const user = os.userInfo().username;
+                        const sidOutput = execSync(`wmic useraccount where name='${user}' get sid`, { stdio: "pipe" }).toString();
+                        const sid = sidOutput.split("\n")[1]?.trim();
+                        if (sid && sid.length > 10)
+                            return sid;
+                    }
+                    catch { }
+                    break;
+                case "darwin":
+                    // macOS: Serial Number
+                    try {
+                        const serial = execSync("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformSerialNumber")
+                            .toString()
+                            .split("=")[1]
+                            ?.trim()
+                            .replace(/"/g, "");
+                        if (serial)
+                            return serial;
+                    }
+                    catch { }
+                    break;
+            }
+        }
+        catch (error) {
+            console.warn("⚠️ Primary HWID method failed, using fallback");
+        }
+        const fallback = [
+            os.hostname(),
+            os.userInfo().username,
+            os.arch(),
+            os.cpus()[0]?.model || "",
+            crypto.randomUUIDv7()
+        ].join("|");
+        return crypto
+            .createHash("sha256")
+            .update(fallback)
+            .digest("hex")
+            .substring(0, 32);
+    }
+    async fail(message, ms = 5000) {
+        if (this.exitOnError) {
+            console.error(message);
+            await this.sleep(ms);
+            process.exit(1);
+        }
+        throw new EpicAuthError(message);
+    }
+    async sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async request(body) {
+        try {
+            const params = new URLSearchParams();
+            for (const [key, value] of Object.entries(body)) {
+                if (value !== undefined) {
+                    params.append(key, String(value));
+                }
+            }
+            const response = await fetch(this.url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                },
+                body: params.toString(),
+            });
+            if (!response.ok) {
+                return this.fail(`HTTP ${response.status}`);
+            }
+            const rawBody = await response.text();
+            if (rawBody === "EpicAuth_Invalid") {
+                return rawBody;
+            }
+            const data = JSON.parse(rawBody);
+            const excludedfuncs = ["file", "log", "2faenable", "2fadisable"];
+            if (excludedfuncs.includes(body.type)) {
+                return data;
+            }
+            const signature = response.headers.get("x-signature-ed25519");
+            const timestamp = response.headers.get("x-signature-timestamp");
+            if (!signature || !timestamp) {
+                return this.fail("Missing signature or timestamp in response headers");
+            }
+            const server_time = new Date(Number(timestamp) * 1000).toUTCString();
+            const current_time = new Date().toUTCString();
+            const buffer_seconds = 5; // Allowable time difference in seconds
+            const time_difference = Math.abs(new Date(server_time).getTime() - new Date(current_time).getTime()) / 1000;
+            if (time_difference > buffer_seconds + 20) {
+                return this.fail(`Time difference is too large: ${time_difference} seconds, try syncing your date and time settings.`);
+            }
+            const message = new TextEncoder().encode(timestamp + rawBody);
+            const signatureBytes = ed.etc.hexToBytes(signature);
+            const publicKeyBytes = ed.etc.hexToBytes(this.public_key);
+            const valid = await ed.verify(signatureBytes, message, publicKeyBytes);
+            if (!valid) {
+                return this.fail("Signature checksum failed. Request was tampered with or session ended most likely.", 3000);
+            }
+            this.logEvent(JSON.stringify(data) + "\n");
+            return data;
+        }
+        catch (error) {
+            return this.fail(`Unexpected error: ${error}`);
+        }
+    }
+    logEvent(message) {
+        console.log(message);
+        if (!this.loggingEnabled)
+            return;
+        const executable = process.argv[1] ?? "unknown";
+        const exeName = executable.split("\\").pop() ?? executable.split("/").pop() ?? "unknown";
+        const logDirectory = path.join(os.homedir(), ".epicauth", "logs", exeName);
+        try {
+            if (!fs.existsSync(logDirectory)) {
+                fs.mkdirSync(logDirectory, { recursive: true });
+            }
+            const logFileName = `${new Date().toLocaleDateString("en-US", { month: "short", day: "2-digit", year: "numeric" }).replace(/ /g, "_")}_logs.txt`;
+            const logFilePath = `${logDirectory}/${logFileName}`;
+            // Redact sensitive fields
+            message = this.redactField(message, "sessionid");
+            message = this.redactField(message, "ownerid");
+            message = this.redactField(message, "app");
+            message = this.redactField(message, "version");
+            message = this.redactField(message, "fileid");
+            message = this.redactField(message, "webhooks");
+            message = this.redactField(message, "nonce");
+            const logMessage = `[${new Date().toISOString()}] [${exeName}] ${message}\n`;
+            fs.appendFileSync(logFilePath, logMessage, "utf-8");
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error logging data: ${error.message}`);
+            }
+            else {
+                console.error("Error logging data: Unknown error");
+            }
+        }
+    }
+    redactField(content, field) {
+        const regex = new RegExp(`"${field}":\\s*".*?"`, "g");
+        return content.replace(regex, `"${field}": "[REDACTED]"`);
+    }
+    load_user_data(data) {
+        const subscription = data.subscriptions[0];
+        if (!subscription) {
+            return this.fail("User has no subscriptions.");
+        }
+        this.user_data = {
+            username: data.username,
+            ip: data.ip,
+            hwid: data.hwid ?? "N/A",
+            expires: Number(subscription.expiry),
+            createdate: Number(data.createdate),
+            lastlogin: Number(data.lastlogin),
+            subscription: subscription.subscription,
+            subscriptions: data.subscriptions,
+        };
+    }
+}

package/dist/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class EpicAuthError extends Error {
+    status?: number | undefined;
+    constructor(message: string, status?: number | undefined);
+}

package/dist/errors.js

@@ -0,0 +1,8 @@
+export class EpicAuthError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = "EpicAuthError";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import EpicAuth from "./client";
+export default EpicAuth;

package/dist/index.js

@@ -0,0 +1,2 @@
+import EpicAuth from "./client";
+export default EpicAuth;

package/dist/types/inputs.d.ts

@@ -0,0 +1,11 @@
+export interface LoginOptions {
+    username: string;
+    password: string;
+    code?: string;
+    hwid?: string;
+}
+export interface LicenseOptions {
+    license: string;
+    code?: string;
+    hwid?: string;
+}

package/dist/types/inputs.js

@@ -0,0 +1 @@
+export {};

package/dist/types/responses.d.ts

@@ -0,0 +1,66 @@
+export interface DownloadResponse {
+    success: boolean;
+    code: number;
+    message: string;
+    download: string;
+    nonce: string;
+    ownerid: string;
+}
+export interface InitResponse {
+    success: boolean;
+    code: number;
+    message: string;
+    sessionid: string;
+    appinfo: {
+        numUsers: string;
+        numOnlineUsers: string;
+        numKeys: string;
+        version: string;
+        customerPanelLink: string;
+    };
+    newSession: boolean;
+    nonce: string;
+    ownerid: string;
+}
+export interface LoginResponse {
+    success: boolean;
+    code: number;
+    message: string;
+    info: {
+        username: string;
+        subscriptions: {
+            subscription: string;
+            key: string;
+            expiry: string;
+            timeleft: number;
+            level: string;
+        }[];
+        ip: string;
+        hwid: string | undefined;
+        createdate: string | number;
+        lastlogin: string;
+    };
+    nonce: string;
+    ownerid: string;
+}
+export interface LicenseResponse {
+    success: boolean;
+    code: number;
+    message: string;
+    info: {
+        username: string;
+        subscriptions: {
+            subscription: string;
+            key: string;
+            expiry: string;
+            timeleft: number;
+            level: string;
+        }[];
+        ip: string;
+        hwid: string | undefined;
+        createdate: string | number;
+        lastlogin: string;
+    };
+    nonce: string;
+    ownerid: string;
+}

package/dist/types/responses.js

@@ -0,0 +1 @@
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,45 @@
+export interface EpicAuthOptions {
+    name: string;
+    ownerid: string;
+    version: string;
+    hash_to_check?: string;
+    url?: string;
+    path?: string;
+    exitOnError?: boolean;
+    loggingEnabled?: boolean;
+}
+export interface ResolvedEpicAuthOptions extends EpicAuthOptions {
+    exitOnError: boolean;
+    loggingEnabled: boolean;
+    url: string;
+    public_key: string;
+}
+export interface ApiResponse<T = unknown> {
+    success: boolean;
+    message: string;
+    data: T;
+}
+export interface EpicAuthUserData {
+    username: string;
+    ip: string;
+    hwid: string;
+    expires: number;
+    createdate: number;
+    lastlogin: number;
+    subscription: string;
+    subscriptions: EpicAuthSubscription[];
+}
+export interface EpicAuthSubscription {
+    subscription: string;
+    key: string;
+    expiry: string;
+    timeleft: number;
+    level: string;
+}
+export interface EpicAuthAppData {
+    numUsers: number;
+    numKeys: number;
+    app_ver: string;
+    customer_panel: string;
+    onlineUsers: number;
+}

package/dist/types/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@epicauth/sdk",
+  "version": "0.1.3",
+  "description": "EpicAuth SDK for Node.js and Bun",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "bun --watch src/index.ts"
+  },
+  "private": false,
+  "license": "Elastic-2.0",
+  "dependencies": {
+    "@noble/ed25519": "^3.1.0",
+    "@noble/hashes": "^2.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9.0"
+  }
+}