Aller au contenu
Xenora

Xenora Docs

API License Cloud

Protégez et vendez vos logiciels : validation, activation par appareil, battements de cœur, gestion des appareils, création et révocation signées.

Authentification et permissions

Chaque application a ses clés API. La clé publique (nx_pk_…) est intégrée au logiciel distribué ; elle valide, active, désactive et lit l'état. La clé secrète (nx_sk_…) reste sur votre serveur ; elle seule crée et révoque des licences, en requêtes signées. Chaque clé peut être restreinte à certaines permissions (portées). Une clé API n'accède jamais à l'administration.

Portées disponibles

licenses:validate · licenses:activate · licenses:deactivate · licenses:heartbeat · licenses:status · devices:read · devices:delete · licenses:create · licenses:revoke

Rotation des clés

« Remplacer » crée une nouvelle clé (et un nouveau secret de signature) ; l'ancienne reste valable 24 heures, le temps de déployer. « Révoquer » coupe immédiatement.

Parcours conseillé

Identifier un appareil

N'utilisez pas d'identifiant matériel. Générez un identifiant d'installation aléatoire (UUID) au premier lancement, gardez-le dans le dossier de configuration de l'application et envoyez-le comme device_id. Xenora n'en stocke que l'empreinte.

  1. Au premier lancement : activate (avec device_id et device_name).
  2. À chaque démarrage puis toutes les next_heartbeat_in secondes : heartbeat.
  3. Si code ≠ VALID : limiter le logiciel et afficher la raison.
  4. À la désinstallation : deactivate pour libérer la place.

Codes de licence

VALID, NOT_FOUND, SUSPENDED, REVOKED, EXPIRED, SUBSCRIPTION_INACTIVE (clé liée à un abonnement terminé), DEVICE_NOT_ACTIVATED.

Requêtes signées (création, révocation)

Calculez HMAC-SHA256 avec le secret de signature (nx_sig_…, affiché une seule fois à la création ou à la rotation de la clé secrète) sur la chaîne « timestamp, nonce, MÉTHODE, chemin, SHA-256 hexadécimal du corps » séparés par des retours à la ligne. Envoyez X-Xenora-Timestamp (secondes Unix, à ±5 minutes), X-Xenora-Nonce (unique) et X-Xenora-Signature. Un nonce rejoué est refusé (REPLAY_DETECTED).

Endpoints

https://api.xenora.bid/v1

  • POST/licenses/validatelicenses:validate · { license_key, device_id? }
  • POST/licenses/activatelicenses:activate · { license_key, device_id, device_name? }
  • POST/licenses/heartbeatlicenses:heartbeat · { license_key, device_id }
  • POST/licenses/deactivatelicenses:deactivate · { license_key, device_id }
  • GET/licenses/statuslicenses:status · X-License-Key
  • GET/licenses/devicesdevices:read · X-License-Key
  • DELETE/licenses/devices/{deviceId}devices:delete · X-License-Key
  • POST/licenseslicenses:create · { key?, kind?, duration_days?, label?, customer_email?, max_devices?, expires_at? } — signée / signed
  • POST/licenses/revokelicenses:revoke · { id | license_key } — signée / signed

Exemples

curl

curl -X POST https://api.xenora.bid/v1/licenses/validate \
  -H "Authorization: Bearer nx_pk_live_…" \
  -H "Content-Type: application/json" \
  -d '{"license_key":"LC-7K2M-9QXA-R4TD-8HNV","device_id":"3f6c…"}'

JavaScript

// Node 18+ / Electron — clé PUBLIQUE uniquement dans le logiciel distribué
import { randomUUID } from "node:crypto";
const API = "https://api.xenora.bid/v1", KEY = "nx_pk_live_…";
const deviceId = loadOrCreate("device-id", () => randomUUID()); // gardé dans le dossier de configuration

async function call(path, body) {
  const res = await fetch(API + path, { method: "POST", headers: { Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" }, body: JSON.stringify(body) });
  const json = await res.json();
  if (!json.success) throw Object.assign(new Error(json.error.message), { code: json.error.code });
  return json.data;
}

await call("/licenses/activate", { license_key: userKey, device_id: deviceId, device_name: os.hostname() });
async function beat() {
  const r = await call("/licenses/heartbeat", { license_key: userKey, device_id: deviceId });
  if (r.code !== "VALID") restrictApp(r.code);
  setTimeout(beat, r.next_heartbeat_in * 1000);
}
beat();

Python

import requests
API = "https://api.xenora.bid/v1"
r = requests.post(f"{API}/licenses/validate",
    headers={"Authorization": "Bearer nx_pk_live_…"},
    json={"license_key": key, "device_id": device_id}, timeout=10)
data = r.json()["data"]
print(data["valid"], data["code"])

Requêtes signées (création, révocation) — JavaScript

// Serveur du vendeur — clé SECRÈTE + secret de signature (jamais dans le logiciel distribué)
import { createHash, createHmac, randomBytes } from "node:crypto";
const SK = process.env.XENORA_SECRET_KEY, SIG = process.env.XENORA_SIGNING_SECRET;

async function signed(method, path, body) {
  const raw = JSON.stringify(body);
  const ts = String(Math.floor(Date.now() / 1000)), nonce = randomBytes(16).toString("base64url");
  const payload = [ts, nonce, method, "/v1" + path, createHash("sha256").update(raw).digest("hex")].join("\n");
  const sig = createHmac("sha256", SIG).update(payload).digest("hex");
  const res = await fetch("https://api.xenora.bid/v1" + path, { method, body: raw, headers: {
    Authorization: `Bearer ${SK}`, "Content-Type": "application/json",
    "X-Xenora-Timestamp": ts, "X-Xenora-Nonce": nonce, "X-Xenora-Signature": sig } });
  return res.json();
}

// Après un paiement : créer une licence de 365 jours qui démarre à l'activation
const { data } = await signed("POST", "/licenses", { duration_days: 365, customer_email: "[email protected]" });
sendToCustomer(data.license.key); // affichée une seule fois

Requêtes signées (création, révocation) — Python

import hashlib, hmac, json, os, secrets, time, requests

def signed(method, path, body):
    raw = json.dumps(body, separators=(",", ":"))
    ts, nonce = str(int(time.time())), secrets.token_urlsafe(16)
    payload = "\n".join([ts, nonce, method, "/v1" + path, hashlib.sha256(raw.encode()).hexdigest()])
    sig = hmac.new(os.environ["XENORA_SIGNING_SECRET"].encode(), payload.encode(), hashlib.sha256).hexdigest()
    return requests.request(method, "https://api.xenora.bid/v1" + path, data=raw, timeout=10, headers={
        "Authorization": "Bearer " + os.environ["XENORA_SECRET_KEY"], "Content-Type": "application/json",
        "X-Xenora-Timestamp": ts, "X-Xenora-Nonce": nonce, "X-Xenora-Signature": sig}).json()

signed("POST", "/licenses/revoke", {"license_key": "LC-7K2M-9QXA-R4TD-8HNV"})

Limites et erreurs

Limite par minute (formule, et éventuellement application) avec en-tête Retry-After, quota mensuel. Toutes les erreurs suivent { success: false, error: { code, message }, request_id } ; gardez request_id pour le support.

Référence complète (OpenAPI 3.1)