Skip to Content

Licencias de Software

Auris Licensing te permite proteger tu software con claves de licencia — valida online, respaldo offline, controla funcionalidades, limita puestos y dispositivos, y automatiza la emisión de claves desde Stripe o PayPal.

Esta guía te lleva a través del flujo completo: crear una política, emitir una clave y validarla en tu app.

Cómo Funciona

┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
│  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    │
└─────────────────┘     └─────────────────┘     └─────────────────┘

Tres modos de validación:

ModoCómo funcionaIdeal para
OnlineCada verificación consulta la APISaaS, apps web, siempre conectado
HybridOnline primero, respaldo JWT si está offlineApps de escritorio, conectividad intermitente
OfflineSolo JWT, sin red necesariaEntornos aislados, embebidos, dispositivos de campo

Inicio Rápido

Crear una Política

En la Consola de Auris, ve a Licensing → Policies → New Policy.

Configura:

  • Name: Vigilante Pro
  • Slug: vigilante-pro
  • Validation Mode: Hybrid
  • Dimensions: Habilita puestos (máx. 3), dispositivos (máx. 2), expiración (365 días)
  • Features: threat-intel, vuln-scan, api-access
  • Key Format: Prefijo VIG, 4 segmentos x 4 caracteres, Base32

Emitir una Clave

Ve a Licensing → Keys → Issue Key, selecciona tu política e ingresa la información del licenciatario. Obtendrás una clave como:

VIG-A8BC-D3EF-G4HJ-K5LM

Instalar el SDK

npm install @auris/js

Validar en Tu App

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.
}

Eso es todo. Una sola llamada a función.

Integración con Apps de Escritorio

Para apps de escritorio (Electron, Tauri, etc.), normalmente querrás activación de dispositivo y respaldo offline.

Ejemplo Completo

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')
  }
}

El respaldo offline funciona porque cada clave de licencia tiene un token JWT asociado que contiene los derechos (funcionalidades, puestos, expiración) firmados por Auris. El SDK valida la firma del JWT y verifica la lista de revocación localmente. El período de gracia (configurable por política, por defecto 7 días) determina cuánto tiempo permanece válida la validación offline.

Integración con Apps Web

Para apps web que están siempre online, solo necesitas 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
}

Integración con React

Usa @auris/react para verificación de licencias basada en 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}</>
}

Automatizar la Emisión de Claves

En lugar de emitir claves manualmente, conecta Stripe o PayPal para emitir claves automáticamente al recibir un pago.

Crear una Regla de Automatización

En la Consola, ve a Licensing → Automation → New Rule:

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

Configurar el Webhook

En el Dashboard de Stripe, agrega un endpoint de webhook:

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

Eventos a escuchar: checkout.session.completed

Configura STRIPE_LICENSING_WEBHOOK_SECRET en tu entorno de Auris API.

Listo

Cuando un cliente completa el checkout, Auris emite automáticamente una clave bajo la política vinculada. La clave está disponible a través de la API y puede enviarse al cliente por correo electrónico o mostrarse en tu app.

Patrones de Control de Funcionalidades

Flags de Funcionalidades Booleanas

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

Acceso por Niveles

// 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'
}

Aplicación de Límite de Puestos

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.')
}

Seguimiento de Uso

Rastrea el uso medido (llamadas API, almacenamiento, etc.) contra una clave:

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' } }

Referencia del SDK

Todas las funciones de licencias se exportan desde @auris/js:

FunciónDescripción
validateLicense(key, domain)Validación online — devuelve validez, funcionalidades, puestos, dispositivos, expiración
validateLicenseJwt(jwt, domain)Validación offline — verifica expiración del JWT + lista de revocación
activateLicense(key, domain, fingerprint, name?)Registrar un dispositivo
deactivateLicense(key, domain, fingerprint)Eliminar un dispositivo
recordLicenseUsage(key, domain, metric, amount?)Rastrear uso medido
getLicenseUsage(key, domain)Obtener uso actual de una clave
refreshRevocationList(domain)Actualizar manualmente la caché de revocación offline

Consulta la referencia completa del SDK de JavaScript y la referencia de la API de Licencias para más detalles.

Arquitectura