Cualquier lenguaje puede activar y comprobar una licencia

función esVálido(token, ahora):
    parts = token.split(".")                     # dos partes, no vacías
    payload = json(base64url_decode(parts[0]))   # leer kid; aún sin confiar
    publicKey = EMBEDDED_KEYS[payload.kid]       # kid desconocido → no válido
    si no ed25519_verify(publicKey, base64url_decode(parts[1]), ascii(parts[0])): devolver NO
    si payload.v != 1 o payload.app != THIS_APP:       devolver NO
    si payload.dev != deviceHash(THIS_APP):         devolver NO
    si payload.lic en savedRevokedList:                devolver NO
    si payload.exp != null y payload.exp <= now:     devolver CADUCADO   # probar /v1/refresh
    devolver SÍ(pro = payload.plan != "free", unidades = payload.qty, funciones = payload.feat)

// WebCrypto (Node 20+, Deno, Bun o un navegador moderno). Funciona tal cual.
const b64url = (s) =>
  Uint8Array.from(atob(s.replace(/-/g, "+").replace(/_/g, "/").padEnd(Math.ceil(s.length / 4) * 4, "=")), (ch) => ch.charCodeAt(0));

async function verify(token, publicKeyB64) {
  const [body, sig] = token.split(".");
  if (!body || !sig) return null;
  const raw = Uint8Array.from(atob(publicKeyB64), (ch) => ch.charCodeAt(0));
  const key = await crypto.subtle.importKey("raw", raw, { name: "Ed25519" }, false, ["verify"]);
  // La firma cubre los caracteres del payload tal cual llegan.
  const ok = await crypto.subtle.verify({ name: "Ed25519" }, key, b64url(sig), new TextEncoder().encode(body));
  return ok ? JSON.parse(new TextDecoder().decode(b64url(body))) : null;
}

// Orientativo: cómo querríamos que fuera el SDK de C#. La API puede cambiar.
var licensing = new OwnLicenseClient(
    baseUrl: new Uri("https://licenses.example.com"),
    app: "myapp",
    publicKeys: new() { ["myapp-live-1"] = "BASE64_PUBLIC_KEY" });

// Activar una vez, con el email y la clave que escribe el cliente.
var result = await licensing.ActivateAsync(email, key);
if (!result.Ok) ShowError(result.Error); // invalid_key, seats_exhausted…

// En cada arranque: comprobar sin conexión y renovar en segundo plano.
var license = licensing.Current();        // null = modo gratuito
_ = licensing.RefreshIfNeededAsync();

// Orientativo: comprobación con CryptoKit de Apple; el SDK de Swift lo envolverá.
import CryptoKit
import Foundation

func base64URLDecode(_ s: String) -> Data? {
    var b = s.replacingOccurrences(of: "-", with: "+").replacingOccurrences(of: "_", with: "/")
    b += String(repeating: "=", count: (4 - b.count % 4) % 4)
    return Data(base64Encoded: b)
}

func verify(token: String, publicKeyBase64: String) -> [String: Any]? {
    let parts = token.split(separator: ".").map(String.init)
    guard parts.count == 2,
          let keyData = Data(base64Encoded: publicKeyBase64),
          let key = try? Curve25519.Signing.PublicKey(rawRepresentation: keyData),
          let signature = base64URLDecode(parts[1]),
          key.isValidSignature(signature, for: Data(parts[0].utf8)),
          let body = base64URLDecode(parts[0]) else { return nil }
    return try? JSONSerialization.jsonObject(with: body) as? [String: Any]
}