Skip to Content

Software-Lizenzierung

Auris Licensing schützt deine Software mit Lizenzschlüsseln — validiere online, nutze Offline-Fallback, steuere Funktionen, begrenze Plätze und Geräte und automatisiere die Schlüsselausstellung über Stripe oder PayPal.

Dieser Leitfaden führt dich durch den gesamten Ablauf: Richtlinie erstellen, Schlüssel ausstellen und in deiner App validieren.

So funktioniert es

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

Drei Validierungsmodi:

ModusFunktionsweiseGeeignet für
OnlineJede Prüfung ruft die API aufSaaS, Web-Apps, immer verbunden
HybridOnline zuerst, JWT-Fallback bei OfflineDesktop-Apps, intermittierende Verbindung
OfflineNur JWT, kein Netzwerk erforderlichAir-Gapped, eingebettete Systeme, Feldgeräte

Schnellstart

Richtlinie erstellen

Gehe in der Auris-Konsole zu Licensing → Policies → New Policy.

Konfiguriere:

  • Name: Vigilante Pro
  • Slug: vigilante-pro
  • Validierungsmodus: Hybrid
  • Dimensionen: Plätze aktivieren (max. 3), Geräte (max. 2), Ablauf (365 Tage)
  • Funktionen: threat-intel, vuln-scan, api-access
  • Schlüsselformat: Präfix VIG, 4 Segmente x 4 Zeichen, Base32

Schlüssel ausstellen

Gehe zu Licensing → Keys → Issue Key, wähle deine Richtlinie und gib die Lizenznehmer-Informationen ein. Du erhältst einen Schlüssel wie:

VIG-A8BC-D3EF-G4HJ-K5LM

SDK installieren

npm install @auris/js

In deiner App validieren

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

Das war’s. Ein Funktionsaufruf.

Desktop-App-Integration

Für Desktop-Apps (Electron, Tauri usw.) benötigst du typischerweise Geräteaktivierung und Offline-Fallback.

Vollständiges Beispiel

import {
  validateLicense,
  validateLicenseJwt,
  activateLicense,
  deactivateLicense,
} from '@auris/js'
 
const DOMAIN = 'auth.yourdomain.com'
 
// ── Schritt 1: Aktivierung (erster Start) ────────────────────────
// Der Benutzer gibt seinen Lizenzschlüssel ein. Du registrierst das Gerät.
 
async function activate(key: string) {
  const fingerprint = getDeviceFingerprint() // e.g. machine UUID
  await activateLicense(key, DOMAIN, fingerprint, os.hostname())
 
  // Schlüssel lokal für zukünftige Starts speichern
  store.set('licenseKey', key)
}
 
// ── Schritt 2: Validierung (bei jedem Start) ────────────────────────
// Lizenz prüfen. Online wenn möglich, Offline-Fallback.
 
async function checkLicense(): Promise<boolean> {
  const key = store.get('licenseKey')
  if (!key) return false
 
  const result = await validateLicense(key, DOMAIN)
 
  // Online-Validierung erfolgreich
  if (result.valid) {
    // JWT für Offline-Nutzung zwischenspeichern
    if (result.jwtToken) store.set('licenseJwt', result.jwtToken)
    return true
  }
 
  // Netzwerkfehler — Offline versuchen
  if (result.reason === 'NETWORK_ERROR') {
    const jwt = store.get('licenseJwt')
    if (jwt) {
      const offline = await validateLicenseJwt(jwt, DOMAIN)
      return offline.valid
    }
  }
 
  return false
}
 
// ── Schritt 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)
}
 
// ── Schritt 4: Deaktivierung (Deinstallation / Abmeldung) ──────────────
 
async function deactivate() {
  const key = store.get('licenseKey')
  if (key) {
    await deactivateLicense(key, DOMAIN, getDeviceFingerprint())
    store.delete('licenseKey')
    store.delete('licenseJwt')
  }
}

Offline-Fallback funktioniert, weil jeder Lizenzschlüssel ein zugehöriges JWT-Token besitzt, das die Berechtigungen (Funktionen, Plätze, Ablauf) enthält und von Auris signiert ist. Das SDK validiert die JWT-Signatur und prüft die Widerrufsliste lokal. Die Karenzzeit (pro Richtlinie konfigurierbar, Standard 7 Tage) bestimmt, wie lange die Offline-Validierung gültig bleibt.

Web-App-Integration

Für Web-Apps, die immer online sind, benötigst du nur validateLicense:

import { validateLicense } from '@auris/js'
 
// Middleware oder 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
}

React-Integration

Verwende @auris/react für Hook-basierte Lizenzprüfung:

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, // 5 Minuten zwischenspeichern
  })
}
 
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}</>
}

Schlüsselausstellung automatisieren

Anstatt Schlüssel manuell auszustellen, verbinde Stripe oder PayPal, um Schlüssel bei Zahlung automatisch auszustellen.

Automatisierungsregel erstellen

Gehe in der Konsole zu Licensing → Automation → New Rule:

  • Anbieter: Stripe
  • Auslöser: checkout.session.completed
  • Aktion: issue_key
  • Verknüpfte Richtlinie: Vigilante Pro

Webhook konfigurieren

Füge im Stripe-Dashboard einen Webhook-Endpunkt hinzu:

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

Zu überwachende Ereignisse: checkout.session.completed

Setze STRIPE_LICENSING_WEBHOOK_SECRET in deiner Auris-API-Umgebung.

Fertig

Wenn ein Kunde den Checkout abschließt, stellt Auris automatisch einen Schlüssel unter der verknüpften Richtlinie aus. Der Schlüssel ist über die API verfügbar und kann dem Kunden per E-Mail gesendet oder in deiner App angezeigt werden.

Feature-Gating-Muster

Boolesche Feature-Flags

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

Stufenbasierter Zugriff

// Stufen als Richtlinien mit verschiedenen Feature-Sets definieren
// 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'
}

Platz-Durchsetzung

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

Nutzungsverfolgung

Verbrauchsbasierte Nutzung (API-Aufrufe, Speicher usw.) gegen einen Schlüssel verfolgen:

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

SDK-Referenz

Alle Lizenzierungsfunktionen werden aus @auris/js exportiert:

FunktionBeschreibung
validateLicense(key, domain)Online-Validierung — gibt Gültigkeit, Funktionen, Plätze, Geräte, Ablauf zurück
validateLicenseJwt(jwt, domain)Offline-Validierung — prüft JWT-Ablauf + Widerrufsliste
activateLicense(key, domain, fingerprint, name?)Ein Gerät registrieren
deactivateLicense(key, domain, fingerprint)Ein Gerät entfernen
recordLicenseUsage(key, domain, metric, amount?)Verbrauchsbasierte Nutzung erfassen
getLicenseUsage(key, domain)Aktuelle Nutzung für einen Schlüssel abrufen
refreshRevocationList(domain)Offline-Widerrufscache manuell aktualisieren

Die vollständige JavaScript SDK-Referenz und Lizenzierungs-API-Referenz findest du dort.

Architektur