Skip to Content

Licences Logicielles

Auris Licensing te permet de protéger ton logiciel avec des clés de licence — valide en ligne, bascule en mode hors connexion, contrôle l’accès aux fonctionnalités, limite les sièges et les appareils, et automatise l’émission de clés depuis Stripe ou PayPal.

Ce guide t’accompagne à travers le flux complet : créer une politique, émettre une clé et la valider dans ton application.

Comment ça fonctionne

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  Auris Console  │     │   Auris API     │     │   Your App      │
│  (Admin UI)     │     │   (Backend)     │     │   (Desktop/Web) │
├─────────────────┤     ├─────────────────┤     ├─────────────────┤
│ Create Policy   │────▶│ Store policy    │     │                 │
│ Issue Key       │────▶│ Generate key    │     │                 │
│                 │     │ + JWT token     │     │                 │
│                 │     │                 │◀────│ validateLicense()│
│                 │     │ Check validity  │────▶│ ✓ or ✗          │
│                 │     │                 │◀────│ activateLicense()│
│                 │     │ Register device │────▶│ Device saved    │
└─────────────────┘     └─────────────────┘     └─────────────────┘

Trois modes de validation :

ModeFonctionnementIdéal pour
OnlineChaque vérification interroge l’APISaaS, applications web, toujours connecté
HybridEn ligne d’abord, fallback JWT si hors connexionApplications de bureau, connectivité intermittente
OfflineJWT uniquement, pas de réseau nécessaireEnvironnements isolés, embarqué, appareils de terrain

Démarrage rapide

Créer une politique

Dans la Console Auris, va dans Licensing → Policies → New Policy.

Configure :

  • Name : Vigilante Pro
  • Slug : vigilante-pro
  • Validation Mode : Hybrid
  • Dimensions : Active les sièges (max 3), appareils (max 2), expiration (365 jours)
  • Features : threat-intel, vuln-scan, api-access
  • Key Format : Préfixe VIG, 4 segments x 4 caractères, Base32

Émettre une clé

Va dans Licensing → Keys → Issue Key, sélectionne ta politique et entre les informations du titulaire. Tu obtiendras une clé comme :

VIG-A8BC-D3EF-G4HJ-K5LM

Installer le SDK

npm install @auris/js

Valider dans ton application

import { validateLicense } from '@auris/js'
 
const result = await validateLicense('VIG-A8BC-D3EF-G4HJ-K5LM', 'auth.yourdomain.com')
 
if (result.valid) {
  console.log('License is valid!')
  console.log('Features:', result.features)   // ['threat-intel', 'vuln-scan', 'api-access']
  console.log('Seats:', result.seats)          // { used: 1, max: 3 }
  console.log('Expires:', result.expiresAt)    // '2027-03-15T00:00:00Z'
} else {
  console.log('Invalid:', result.reason)       // 'EXPIRED', 'REVOKED', etc.
}

C’est tout. Un seul appel de fonction.

Intégration application de bureau

Pour les applications de bureau (Electron, Tauri, etc.), tu voudras généralement l’activation d’appareils et le fallback hors connexion.

Exemple complet

import {
  validateLicense,
  validateLicenseJwt,
  activateLicense,
  deactivateLicense,
} from '@auris/js'
 
const DOMAIN = 'auth.yourdomain.com'
 
// ── Step 1: Activation (first launch) ────────────────────────
// The user enters their license key. You register the device.
 
async function activate(key: string) {
  const fingerprint = getDeviceFingerprint() // e.g. machine UUID
  await activateLicense(key, DOMAIN, fingerprint, os.hostname())
 
  // Save key locally for future launches
  store.set('licenseKey', key)
}
 
// ── Step 2: Validation (every launch) ────────────────────────
// Check the license. Online if possible, offline fallback.
 
async function checkLicense(): Promise<boolean> {
  const key = store.get('licenseKey')
  if (!key) return false
 
  const result = await validateLicense(key, DOMAIN)
 
  // Online validation succeeded
  if (result.valid) {
    // Cache the JWT for offline use
    if (result.jwtToken) store.set('licenseJwt', result.jwtToken)
    return true
  }
 
  // Network error — try offline
  if (result.reason === 'NETWORK_ERROR') {
    const jwt = store.get('licenseJwt')
    if (jwt) {
      const offline = await validateLicenseJwt(jwt, DOMAIN)
      return offline.valid
    }
  }
 
  return false
}
 
// ── Step 3: Feature gating ───────────────────────────────────
 
async function hasFeature(feature: string): Promise<boolean> {
  const result = await validateLicense(store.get('licenseKey')!, DOMAIN)
  return result.valid && (result.features?.includes(feature) ?? false)
}
 
// ── Step 4: Deactivation (uninstall / sign out) ──────────────
 
async function deactivate() {
  const key = store.get('licenseKey')
  if (key) {
    await deactivateLicense(key, DOMAIN, getDeviceFingerprint())
    store.delete('licenseKey')
    store.delete('licenseJwt')
  }
}

Le fallback hors connexion fonctionne car chaque clé de licence possède un token JWT associé contenant les droits (fonctionnalités, sièges, expiration) signés par Auris. Le SDK valide la signature JWT et vérifie la liste de révocation localement. La période de grâce (configurable par politique, 7 jours par défaut) détermine la durée de validité de la validation hors connexion.

Intégration application web

Pour les applications web toujours connectées, tu n’as besoin que de validateLicense :

import { validateLicense } from '@auris/js'
 
// Middleware or API route
export async function checkLicense(licenseKey: string) {
  const result = await validateLicense(licenseKey, 'auth.yourdomain.com')
  if (!result.valid) throw new Error(`License invalid: ${result.reason}`)
  return result
}

Intégration React

Utilise @auris/react pour la vérification de licence via des hooks :

import { useAuris } from '@auris/react'
import { validateLicense } from '@auris/js'
import { useQuery } from '@tanstack/react-query'
 
function useLicense(key: string) {
  const { domain } = useAuris()
  return useQuery({
    queryKey: ['license', key],
    queryFn: () => validateLicense(key, domain),
    staleTime: 5 * 60 * 1000, // cache for 5 minutes
  })
}
 
function ProFeature({ children }: { children: React.ReactNode }) {
  const { data } = useLicense(userLicenseKey)
 
  if (!data?.valid) return <UpgradePrompt />
  if (!data.features?.includes('pro-feature')) return <UpgradePrompt />
 
  return <>{children}</>
}

Automatiser l’émission de clés

Au lieu d’émettre des clés manuellement, connecte Stripe ou PayPal pour émettre automatiquement des clés lors du paiement.

Créer une règle d’automatisation

Dans la Console, va dans Licensing → Automation → New Rule :

  • Provider : Stripe
  • Trigger : checkout.session.completed
  • Action : issue_key
  • Linked Policy : Vigilante Pro

Configurer le webhook

Dans le tableau de bord Stripe, ajoute un endpoint de webhook :

https://auth.yourdomain.com/api/licensing/webhooks/stripe

Événements à écouter : checkout.session.completed

Configure STRIPE_LICENSING_WEBHOOK_SECRET dans l’environnement de ton API Auris.

Terminé

Lorsqu’un client complète le checkout, Auris émet automatiquement une clé sous la politique liée. La clé est disponible via l’API et peut être envoyée au client par e-mail ou affichée dans ton application.

Patterns de contrôle d’accès aux fonctionnalités

Drapeaux de fonctionnalités booléens

const result = await validateLicense(key, domain)
 
const canExport = result.features?.includes('export') ?? false
const canUseApi = result.features?.includes('api-access') ?? false

Accès par niveaux

// Define tiers as policies with different feature sets
// Free:  ['basic']
// Pro:   ['basic', 'analytics', 'export']
// Enterprise: ['basic', 'analytics', 'export', 'api-access', 'sso']
 
function getTier(features: string[]): 'free' | 'pro' | 'enterprise' {
  if (features.includes('sso')) return 'enterprise'
  if (features.includes('analytics')) return 'pro'
  return 'free'
}

Application de la limite de sièges

const result = await validateLicense(key, domain)
 
if (result.seats && result.seats.used >= (result.seats.max ?? Infinity)) {
  throw new Error('Seat limit reached. Please upgrade your plan.')
}

Suivi d’utilisation

Suis l’utilisation à la consommation (appels API, stockage, etc.) pour une clé :

import { recordLicenseUsage, getLicenseUsage } from '@auris/js'
 
// Record usage
await recordLicenseUsage(key, domain, 'api_calls', 1)
 
// Check usage
const usage = await getLicenseUsage(key, domain)
// { api_calls: { used: 142, max: 1000, period: 'month', resetsAt: '2026-04-01' } }

Référence SDK

Toutes les fonctions de licence sont exportées depuis @auris/js :

FonctionDescription
validateLicense(key, domain)Validation en ligne — retourne la validité, les fonctionnalités, les sièges, les appareils, l’expiration
validateLicenseJwt(jwt, domain)Validation hors connexion — vérifie l’expiration du JWT et la liste de révocation
activateLicense(key, domain, fingerprint, name?)Enregistrer un appareil
deactivateLicense(key, domain, fingerprint)Retirer un appareil
recordLicenseUsage(key, domain, metric, amount?)Suivre l’utilisation à la consommation
getLicenseUsage(key, domain)Obtenir l’utilisation actuelle d’une clé
refreshRevocationList(domain)Rafraîchir manuellement le cache de révocation hors connexion

Consulte la référence complète du SDK JavaScript et la référence de l’API de Licences pour plus de détails.

Architecture