BuyBizz Vendor License API

// npm i node-machine-id
import { machineIdSync } from "node-machine-id";
import crypto from "crypto";

export function fingerprint(): string {
  const raw = machineIdSync(/* original=false */);
  return crypto.createHash("sha256").update(raw).digest("hex");
}

import hashlib, platform, uuid

def fingerprint() -> str:
    raw = f"{uuid.getnode()}:{platform.node()}"
    return hashlib.sha256(raw.encode()).hexdigest()

// Don't fingerprint the browser; fingerprint the *account*.
// Stable across logins, devices, and incognito windows.
import crypto from "crypto";

export function fingerprint(userId: string, tenantId: string): string {
  return crypto
    .createHash("sha256")
    .update(`${tenantId}:${userId}`)
    .digest("hex");
}

using System.Management;
using System.Security.Cryptography;
using System.Text;

string Fingerprint() {
  using var s = new ManagementObjectSearcher("SELECT UUID FROM Win32_ComputerSystemProduct");
  var raw = s.Get().Cast<ManagementObject>().First()["UUID"].ToString();
  using var sha = SHA256.Create();
  return Convert.ToHexString(sha.ComputeHash(Encoding.UTF8.GetBytes(raw))).ToLower();
}

import CryptoKit
import UIKit

func fingerprint() -> String {
  let raw = UIDevice.current.identifierForVendor?.uuidString ?? "unknown"
  let digest = SHA256.hash(data: Data(raw.utf8))
  return digest.map { String(format: "%02x", $0) }.joined()
}

import android.provider.Settings
import java.security.MessageDigest

fun fingerprint(context: Context): String {
  val raw = Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID)
  val digest = MessageDigest.getInstance("SHA-256").digest(raw.toByteArray())
  return digest.joinToString("") { "%02x".format(it) }
}

import crypto from "crypto";
import fs from "fs";

const SECRET = process.env.BUYBIZZ_SECRET!;
const CACHE_FILE = "/var/lib/myapp/license-cache.json";
const CACHE_TTL_MS = 30 * 60 * 1000;        // re-check after 30 min
const GRACE_MS    = 7 * 24 * 60 * 60 * 1000; // up to 7 days offline

async function verifyOnce(key: string, slug: string) {
  const res = await fetch("https://api.buybizz.app/api/v1/licenses/heartbeat", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.BUYBIZZ_KEY_PREFIX}.${SECRET}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ key, productSlug: slug }),
  });
  // (omitted: signature verification — see "Verifying response signatures")
  return { status: res.status, body: await res.json() };
}

export async function isLicenseValid(key: string, slug: string): Promise<boolean> {
  let cached: { ok: boolean; at: number } | null = null;
  try { cached = JSON.parse(fs.readFileSync(CACHE_FILE, "utf8")); } catch {}

  if (cached && Date.now() - cached.at < CACHE_TTL_MS) return cached.ok;

  const delays = [1000, 2000, 4000, 8000];
  for (let i = 0; i < delays.length; i++) {
    try {
      const { status, body } = await verifyOnce(key, slug);
      if (status === 200 && body.valid === true) {
        fs.writeFileSync(CACHE_FILE, JSON.stringify({ ok: true, at: Date.now() }));
        return true;
      }
      if (status === 200 && body.valid === false) {
        // stable rejection — don't retry, don't grace
        fs.writeFileSync(CACHE_FILE, JSON.stringify({ ok: false, at: Date.now() }));
        return false;
      }
      if (status === 401) return false; // bad credentials — operator problem
    } catch { /* network error, fall through to retry */ }
    await new Promise(r => setTimeout(r, delays[i]));
  }
  // All retries failed — fall back to last known-good if within grace window.
  if (cached?.ok && Date.now() - cached.at < GRACE_MS) return true;
  return false;
}